magma_morse_z.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	COMPLEX
#define	PRECISION_z

Functions
int	MAGMA_zgelqf (int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T)
int	MAGMA_zgelqs (int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zgels (PLASMA_enum trans, int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zgemm (PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_zgeqrf (int M, int N, PLASMA_Complex64_t *A, int LDA, magma_desc_t *T)
int	MAGMA_zgeqrs (int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zgesv (int N, int NRHS, PLASMA_Complex64_t *A, int LDA, magma_desc_t *L, int *IPIV, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zgetrf (int M, int N, PLASMA_Complex64_t *A, int LDA, magma_desc_t *L, int *IPIV)
int	MAGMA_zgetrs (PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, magma_desc_t *L, int *IPIV, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zhemm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_zherk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, double alpha, PLASMA_Complex64_t *A, int LDA, double beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_zher2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, double beta, PLASMA_Complex64_t *C, int LDC)
double	MAGMA_zlange (PLASMA_enum norm, int M, int N, PLASMA_Complex64_t *A, int LDA, double *work)
double	MAGMA_zlanhe (PLASMA_enum norm, PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA, double *work)
double	MAGMA_zlansy (PLASMA_enum norm, PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA, double *work)
int	MAGMA_zlauum (PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
int	MAGMA_zplghe (double bump, int N, PLASMA_Complex64_t *A, int LDA, unsigned long long int seed)
int	MAGMA_zplgsy (PLASMA_Complex64_t bump, int N, PLASMA_Complex64_t *A, int LDA, unsigned long long int seed)
int	MAGMA_zplrnt (int M, int N, PLASMA_Complex64_t *A, int LDA, unsigned long long int seed)
int	MAGMA_zposv (PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zpotrf (PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
int	MAGMA_zpotri (PLASMA_enum uplo, int N, PLASMA_Complex64_t *A, int LDA)
int	MAGMA_zpotrs (PLASMA_enum uplo, int N, int NRHS, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zsymm (PLASMA_enum side, PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_zsyrk (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_zsyr2k (PLASMA_enum uplo, PLASMA_enum trans, int N, int K, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int LDC)
int	MAGMA_ztrmm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_ztrsm (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, int N, int NRHS, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_ztrsmpl (int N, int NRHS, PLASMA_Complex64_t *A, int LDA, magma_desc_t *L, int *IPIV, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_ztrtri (PLASMA_enum uplo, PLASMA_enum diag, int N, PLASMA_Complex64_t *A, int LDA)
int	MAGMA_zunglq (int M, int N, int K, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zungqr (int M, int N, int K, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zunmlq (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zunmqr (PLASMA_enum side, PLASMA_enum trans, int M, int N, int K, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, PLASMA_Complex64_t *B, int LDB)
int	MAGMA_zgecfi (int m, int n, PLASMA_Complex64_t *A, PLASMA_enum fin, int imb, int inb, PLASMA_enum fout, int omb, int onb)
int	MAGMA_zgetmi (int m, int n, PLASMA_Complex64_t *A, PLASMA_enum fin, int mb, int nb)
int	MAGMA_zgelqf_Tile (magma_desc_t *A, magma_desc_t *T)
int	MAGMA_zgelqs_Tile (magma_desc_t *A, magma_desc_t *B, magma_desc_t *T)
int	MAGMA_zgels_Tile (PLASMA_enum trans, magma_desc_t *A, magma_desc_t *B, magma_desc_t *T)
int	MAGMA_zgemm_Tile (PLASMA_enum transA, PLASMA_enum transB, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C)
int	MAGMA_zgeqrf_Tile (magma_desc_t *A, magma_desc_t *T)
int	MAGMA_zgeqrs_Tile (magma_desc_t *A, magma_desc_t *B, magma_desc_t *T)
int	MAGMA_zgesv_Tile (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B)
int	MAGMA_zgetrf_Tile (magma_desc_t *A, magma_desc_t *L, int *IPIV)
int	MAGMA_zgetrs_Tile (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B)
int	MAGMA_zhemm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C)
int	MAGMA_zherk_Tile (PLASMA_enum uplo, PLASMA_enum trans, double alpha, magma_desc_t *A, double beta, magma_desc_t *C)
int	MAGMA_zher2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, double beta, magma_desc_t *C)
double	MAGMA_zlange_Tile (PLASMA_enum norm, magma_desc_t *A, double *work)
double	MAGMA_zlanhe_Tile (PLASMA_enum norm, PLASMA_enum uplo, magma_desc_t *A, double *work)
double	MAGMA_zlansy_Tile (PLASMA_enum norm, PLASMA_enum uplo, magma_desc_t *A, double *work)
int	MAGMA_zlauum_Tile (PLASMA_enum uplo, magma_desc_t *A)
int	MAGMA_zplghe_Tile (double bump, magma_desc_t *A, unsigned long long int seed)
int	MAGMA_zplgsy_Tile (PLASMA_Complex64_t bump, magma_desc_t *A, unsigned long long int seed)
int	MAGMA_zplrnt_Tile (magma_desc_t *A, unsigned long long int seed)
int	MAGMA_zposv_Tile (PLASMA_enum uplo, magma_desc_t *A, magma_desc_t *B)
int	MAGMA_zpotrf_Tile (PLASMA_enum uplo, magma_desc_t *A)
int	MAGMA_zpotri_Tile (PLASMA_enum uplo, magma_desc_t *A)
int	MAGMA_zpotrs_Tile (PLASMA_enum uplo, magma_desc_t *A, magma_desc_t *B)
int	MAGMA_zsymm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C)
int	MAGMA_zsyrk_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, PLASMA_Complex64_t beta, magma_desc_t *C)
int	MAGMA_zsyr2k_Tile (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C)
int	MAGMA_ztrmm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B)
int	MAGMA_ztrsm_Tile (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B)
int	MAGMA_ztrsmpl_Tile (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B)
int	MAGMA_ztrtri_Tile (PLASMA_enum uplo, PLASMA_enum diag, magma_desc_t *A)
int	MAGMA_zunglq_Tile (magma_desc_t *A, magma_desc_t *T, magma_desc_t *B)
int	MAGMA_zungqr_Tile (magma_desc_t *A, magma_desc_t *T, magma_desc_t *B)
int	MAGMA_zunmlq_Tile (PLASMA_enum side, PLASMA_enum trans, magma_desc_t *A, magma_desc_t *T, magma_desc_t *B)
int	MAGMA_zunmqr_Tile (PLASMA_enum side, PLASMA_enum trans, magma_desc_t *A, magma_desc_t *T, magma_desc_t *B)
int	MAGMA_zgelqf_Tile_Async (magma_desc_t *A, magma_desc_t *T, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgelqs_Tile_Async (magma_desc_t *A, magma_desc_t *B, magma_desc_t *T, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgels_Tile_Async (PLASMA_enum trans, magma_desc_t *A, magma_desc_t *B, magma_desc_t *T, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgemm_Tile_Async (PLASMA_enum transA, PLASMA_enum transB, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgeqrf_Tile_Async (magma_desc_t *A, magma_desc_t *T, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgeqrs_Tile_Async (magma_desc_t *A, magma_desc_t *B, magma_desc_t *T, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgesv_Tile_Async (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgetrf_Tile_Async (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgetrs_Tile_Async (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zhemm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zherk_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, double alpha, magma_desc_t *A, double beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zher2k_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, double beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zlange_Tile_Async (PLASMA_enum norm, magma_desc_t *A, double *work, double *value, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zlanhe_Tile_Async (PLASMA_enum norm, PLASMA_enum uplo, magma_desc_t *A, double *work, double *value, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zlansy_Tile_Async (PLASMA_enum norm, PLASMA_enum uplo, magma_desc_t *A, double *work, double *value, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zlauum_Tile_Async (PLASMA_enum uplo, magma_desc_t *A, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zplghe_Tile_Async (double bump, magma_desc_t *A, unsigned long long int seed, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zplgsy_Tile_Async (PLASMA_Complex64_t bump, magma_desc_t *A, unsigned long long int seed, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zplrnt_Tile_Async (magma_desc_t *A, unsigned long long int seed, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zposv_Tile_Async (PLASMA_enum uplo, magma_desc_t *A, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zpotrf_Tile_Async (PLASMA_enum uplo, magma_desc_t *A, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zpotri_Tile_Async (PLASMA_enum uplo, magma_desc_t *A, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zpotrs_Tile_Async (PLASMA_enum uplo, magma_desc_t *A, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zsymm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zsyrk_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, PLASMA_Complex64_t beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zsyr2k_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, PLASMA_Complex64_t beta, magma_desc_t *C, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_ztrmm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_ztrsm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex64_t alpha, magma_desc_t *A, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_ztrsmpl_Tile_Async (magma_desc_t *A, magma_desc_t *L, int *IPIV, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_ztrtri_Tile_Async (PLASMA_enum uplo, PLASMA_enum diag, magma_desc_t *A, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zunglq_Tile_Async (magma_desc_t *A, magma_desc_t *T, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zungqr_Tile_Async (magma_desc_t *A, magma_desc_t *T, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zunmlq_Tile_Async (PLASMA_enum side, PLASMA_enum trans, magma_desc_t *A, magma_desc_t *T, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zunmqr_Tile_Async (PLASMA_enum side, PLASMA_enum trans, magma_desc_t *A, magma_desc_t *T, magma_desc_t *B, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgecfi_Async (int m, int n, PLASMA_Complex64_t *A, PLASMA_enum f_in, int imb, int inb, PLASMA_enum f_out, int omb, int onb, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zgetmi_Async (int m, int n, PLASMA_Complex64_t *A, PLASMA_enum f_in, int mb, int inb, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zLapack_to_Tile (PLASMA_Complex64_t *Af77, int LDA, magma_desc_t *A)
int	MAGMA_zTile_to_Lapack (magma_desc_t *A, PLASMA_Complex64_t *Af77, int LDA)
int	MAGMA_zLapack_to_Tile_Async (PLASMA_Complex64_t *Af77, int LDA, magma_desc_t *A, magma_sequence_t *sequence, magma_request_t *request)
int	MAGMA_zTile_to_Lapack_Async (magma_desc_t *A, PLASMA_Complex64_t *Af77, int LDA, magma_sequence_t *sequence, magma_request_t *request)

---

Macro Definition Documentation

#define COMPLEX

Definition at line 20 of file magma_morse_z.h.

#define PRECISION_z

Definition at line 26 of file magma_morse_z.h.

---

Function Documentation

int MAGMA_zgecfi	(	int	m,
		int	n,
		PLASMA_Complex64_t *	A,
		PLASMA_enum	fin,
		int	imb,
		int	inb,
		PLASMA_enum	fout,
		int	omb,
		int	onb
	)

int MAGMA_zgecfi_Async	(	int	m,
		int	n,
		PLASMA_Complex64_t *	A,
		PLASMA_enum	f_in,
		int	imb,
		int	inb,
		PLASMA_enum	f_out,
		int	omb,
		int	onb,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zgelqf	(	int	M,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T
	)

---

Declarations of math functions (LAPACK layout) - alphabetical order

int MAGMA_zgelqf_Tile	(	magma_desc_t *	A,
		magma_desc_t *	T
	)

---

Declarations of math functions (tile layout) - alphabetical order

int MAGMA_zgelqf_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

---

Declarations of math functions (tile layout, asynchronous execution) - alphabetical order

int MAGMA_zgelqs	(	int	M,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zgelqs_Tile	(	magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T
	)

int MAGMA_zgelqs_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zgels	(	PLASMA_enum	trans,
		int	M,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zgels_Tile	(	PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T
	)

int MAGMA_zgels_Tile_Async	(	PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zgemm	(	PLASMA_enum	transA,
		PLASMA_enum	transB,
		int	M,
		int	N,
		int	K,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB,
		PLASMA_Complex64_t	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

MAGMA_zgemm - Performs one of the matrix-matrix operations

,

where op( X ) is one of

op( X ) = X or op( X ) = X' or op( X ) = conjg( X' )

alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

Parameters:

[in]	transA	Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
[in]	transB	Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaConjTrans: B is conjugate transposed.
[in]	M	M specifies the number of rows of the matrix op( A ) and of the matrix C. M >= 0.
[in]	N	N specifies the number of columns of the matrix op( B ) and of the matrix C. N >= 0.
[in]	K	K specifies the number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). K >= 0.
[in]	alpha	alpha specifies the scalar alpha
[in]	A	A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[in]	B	B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).
[in]	beta	beta specifies the scalar beta
[in,out]	C	C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )
[in]	LDC	The leading dimension of the array C. LDC >= max(1,M).

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zgemm_Tile

MAGMA_cgemm

MAGMA_dgemm

MAGMA_sgemm

Definition at line 96 of file zgemm.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, MAGMA_zgemm_Tile_Async(), magma_zooplap2tile, magma_zooptile2lap, max, morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    int NB;
    int Am, An, Bm, Bn;
    int status;
    magma_desc_t descA, descB, descC;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgemm", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }

    /* Check input arguments */
    if ((transA != PlasmaNoTrans) && (transA != PlasmaTrans) && (transA != PlasmaConjTrans)) {
        magma_error("MAGMA_zgemm", "illegal value of transA");
        return -1;
    }
    if ((transB != PlasmaNoTrans) && (transB != PlasmaTrans) && (transB != PlasmaConjTrans)) {
        magma_error("MAGMA_zgemm", "illegal value of transB");
        return -2;
    }
    if ( transA == PlasmaNoTrans ) { 
        Am = M; An = K;
    } else {
        Am = K; An = M;
    }
    if ( transB == PlasmaNoTrans ) { 
        Bm = K; Bn = N;
    } else {
        Bm = N; Bn = K;
    }
    if (M < 0) {
        magma_error("MAGMA_zgemm", "illegal value of M");
        return -3;
    }
    if (N < 0) {
        magma_error("MAGMA_zgemm", "illegal value of N");
        return -4;
    }
    if (K < 0) {
        magma_error("MAGMA_zgemm", "illegal value of N");
        return -5;
    }
    if (LDA < max(1, Am)) {
        magma_error("MAGMA_zgemm", "illegal value of LDA");
        return -8;
    }
    if (LDB < max(1, Bm)) {
        magma_error("MAGMA_zgemm", "illegal value of LDB");
        return -10;
    }
    if (LDC < max(1, M)) {
        magma_error("MAGMA_zgemm", "illegal value of LDC");
        return -13;
    }

    /* Quick return */
    if (M == 0 || N == 0 ||
        ((alpha == (PLASMA_Complex64_t)0.0 || K == 0) && beta == (PLASMA_Complex64_t)1.0))
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNBSIZE */
    /* status = magma_tune(MAGMA_FUNC_ZGEMM, M, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zgemm", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set MT && NT && KT */
    NB = MAGMA_NB;

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, Bn, 0, 0, Bm, Bn, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
        magma_zooplap2tile( descC, C, NB, NB, LDC, N,  0, 0, M,  N,  magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)); magma_desc_mat_free(&(descC)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, Bn, 0, 0, Bm, Bn ); */
    /*     magma_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, M,  N  ); */
    /* } */

    /* Call the tile interface */
    MAGMA_zgemm_Tile_Async(
        transA, transB, alpha, &descA, &descB, beta, &descC, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descC, C, NB, NB, LDC, N );
        morse_barrier( magma );
        morse_desc_getoncpu( &descC );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
        magma_desc_mat_free(&descC);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, An ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, Bn ); */
    /*     magma_ziptile2lap( descC, C, NB, NB, LDC, N  ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgemm_Tile	(	PLASMA_enum	transA,
		PLASMA_enum	transB,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C
	)

MAGMA_zgemm_Tile - Performs matrix multiplication. Tile equivalent of MAGMA_zgemm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	transA	Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is not transposed; = PlasmaTrans: A is transposed; = PlasmaConjTrans: A is conjugate transposed.
[in]	transB	Specifies whether the matrix B is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: B is not transposed; = PlasmaTrans: B is transposed; = PlasmaConjTrans: B is conjugate transposed.
[in]	alpha	alpha specifies the scalar alpha
[in]	A	A is a LDA-by-ka matrix, where ka is K when transA = PlasmaNoTrans, and is M otherwise.
[in]	B	B is a LDB-by-kb matrix, where kb is N when transB = PlasmaNoTrans, and is K otherwise.
[in]	beta	beta specifies the scalar beta
[in,out]	C	C is a LDC-by-N matrix. On exit, the array is overwritten by the M by N matrix ( alpha*op( A )*op( B ) + beta*C )

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zgemm

MAGMA_zgemm_Tile_Async

MAGMA_cgemm_Tile

MAGMA_dgemm_Tile

MAGMA_sgemm_Tile

Definition at line 265 of file zgemm.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zgemm_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgemm_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zgemm_Tile_Async(transA, transB, alpha, A, B, beta, C, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( B );
    morse_desc_getoncpu( C );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgemm_Tile_Async	(	PLASMA_enum	transA,
		PLASMA_enum	transB,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zgemm_Tile_Async - Performs matrix multiplication. Non-blocking equivalent of MAGMA_zgemm_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zgemm

MAGMA_zgemm_Tile

MAGMA_cgemm_Tile_Async

MAGMA_dgemm_Tile_Async

MAGMA_sgemm_Tile_Async

Definition at line 317 of file zgemm.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzgemm(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    magma_context_t *magma;
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    PLASMA_desc descC = C->desc;
    int M, N, K;
    int Am, An, Ai, Aj, Amb, Anb;
    int Bm, Bn, Bi, Bj, Bmb, Bnb;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgemm_Tile_Async", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zgemm_Tile_Async", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zgemm_Tile_Async", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgemm_Tile_Async", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgemm_Tile_Async", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( C ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgemm_Tile_Async", "invalid third descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if ((transA != PlasmaNoTrans) && (transA != PlasmaTrans) && (transA != PlasmaConjTrans)) {
        magma_error("MAGMA_zgemm_Tile_Async", "illegal value of transA");
        return magma_request_fail(sequence, request, -1);
    }
    if ((transB != PlasmaNoTrans) && (transB != PlasmaTrans) && (transB != PlasmaConjTrans)) {
        magma_error("MAGMA_zgemm_Tile_Async", "illegal value of transB");
        return magma_request_fail(sequence, request, -2);
    }

    if ( transA == PlasmaNoTrans ) {
        Am  = descA.m;
        An  = descA.n;
        Amb = descA.mb;
        Anb = descA.nb;
        Ai  = descA.i;
        Aj  = descA.j;
    } else {
        Am  = descA.n;
        An  = descA.m;
        Amb = descA.nb;
        Anb = descA.mb;
        Ai  = descA.j;
        Aj  = descA.i;
    }

    if ( transB == PlasmaNoTrans ) {
        Bm  = descB.m;
        Bn  = descB.n;
        Bmb = descB.mb;
        Bnb = descB.nb;
        Bi  = descB.i;
        Bj  = descB.j;
    } else {
        Bm  = descB.n;
        Bn  = descB.m;
        Bmb = descB.nb;
        Bnb = descB.mb;
        Bi  = descB.j;
        Bj  = descB.i;
    }

    if ( (Amb != descC.mb) || (Anb != Bmb) || (Bnb != descC.nb) ) {
        magma_error("MAGMA_zgemm_Tile_Async", "tile sizes have to match");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if ( (Am != descC.m) || (An != Bm) || (Bn != descC.n) ) {
        magma_error("MAGMA_zgemm_Tile_Async", "sizes of matrices have to match");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if ( (Ai != descC.i) || (Aj != Bi) || (Bj != descC.j) ) {
        magma_error("MAGMA_zgemm_Tile_Async", "start indexes have to match");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }

    M = descC.m;
    N = descC.n;
    K = An;

    /* Quick return */
    if (M == 0 || N == 0 ||
        ((alpha == (PLASMA_Complex64_t)0.0 || K == 0) && beta == (PLASMA_Complex64_t)1.0))
        return MAGMA_SUCCESS;

    magma_pzgemm( transA, transB,
                  alpha, A, B,
                  beta, C,
                  sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgeqrf	(	int	M,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		magma_desc_t *	T
	)

MAGMA_zgeqrf - Computes the tile QR factorization of a complex M-by-N matrix A: A = Q * R.

Parameters:

[in]	M	The number of rows of the matrix A. M >= 0.
[in]	N	The number of columns of the matrix A. N >= 0.
[in,out]	A	On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[out]	T	On exit, auxiliary factorization data, required by MAGMA_zgeqrs to solve the system of equations.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_zgeqrf_Tile

MAGMA_zgeqrf_Tile_Async

MAGMA_cgeqrf

MAGMA_dgeqrf

MAGMA_sgeqrf

MAGMA_zgeqrs

Definition at line 61 of file zgeqrf.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_IB, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, MAGMA_zgeqrf_Tile_Async(), magma_zooplap2tile, magma_zooptile2lap, max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, IB, IBNB, MT, NT;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgeqrf", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (M < 0) {
        magma_error("MAGMA_zgeqrf", "illegal value of M");
        return -1;
    }
    if (N < 0) {
        magma_error("MAGMA_zgeqrf", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, M)) {
        magma_error("MAGMA_zgeqrf", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (min(M, N) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB && IB depending on M, N && NRHS; Set NBNBSIZE */
    /* status = magma_tune(MAGMA_FUNC_ZGELS, M, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zgeqrf", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set MT && NT */
    NB   = MAGMA_NB;
    IB   = MAGMA_IB;
    IBNB = IB*NB;
    MT   = (M%NB==0) ? (M/NB) : (M/NB+1);
    NT   = (N%NB==0) ? (N/NB) : (N/NB+1);

    magma_sequence_create(magma, &sequence);
 
    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N, magma_desc_mat_free(&(descA)) );
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N); */
    /* } */

    /* Call the tile interface */
    MAGMA_zgeqrf_Tile_Async(&descA, T, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descA, A, NB, NB, LDA, N );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgeqrf_Tile	(	magma_desc_t *	A,
		magma_desc_t *	T
	)

MAGMA_zgeqrf_Tile - Computes the tile QR factorization of a matrix. Tile equivalent of MAGMA_zgeqrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in,out]	A	On entry, the M-by-N matrix A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal matrix R (R is upper triangular if M >= N); the elements below the diagonal represent the unitary matrix Q as a product of elementary reflectors stored by tiles.
[out]	T	On exit, auxiliary factorization data, required by MAGMA_zgeqrs to solve the system of equations.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zgeqrf

MAGMA_zgeqrf_Tile_Async

MAGMA_cgeqrf_Tile

MAGMA_dgeqrf_Tile

MAGMA_sgeqrf_Tile

MAGMA_zgeqrs_Tile

Definition at line 171 of file zgeqrf.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zgeqrf_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgeqrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zgeqrf_Tile_Async(A, T, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( T );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgeqrf_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zgeqrf_Tile_Async - Computes the tile QR factorization of a matrix. Non-blocking equivalent of MAGMA_zgeqrf_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zgeqrf

MAGMA_zgeqrf_Tile

MAGMA_cgeqrf_Tile_Async

MAGMA_dgeqrf_Tile_Async

MAGMA_sgeqrf_Tile_Async

MAGMA_zgeqrs_Tile_Async

Definition at line 221 of file zgeqrf.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzgeqrf(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_error("MAGMA_zgeqrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zgeqrf_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zgeqrf_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgeqrf_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( T ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgeqrf_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zgeqrf_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
/*
    if (min(M, N) == 0)
        return MAGMA_SUCCESS;
*/
    /* if (magma->householder == MAGMA_FLAT_HOUSEHOLDER) { */

    magma_pzgeqrf( A, T, sequence, request);

    /* } */
    /* else { */
    /*     magma_dynamic_call_5(magma_pzgeqrfrh, */
    /*         magma_desc_t, descA, */
    /*         magma_desc_t, descT, */
    /*         MAGMA_enum, MAGMA_RHBLK, */
    /*         magma_sequence_t*, sequence, */
    /*         magma_request_t*, request); */
    /* } */

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgeqrs	(	int	M,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zgeqrs_Tile	(	magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T
	)

int MAGMA_zgeqrs_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	B,
		magma_desc_t *	T,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zgesv	(	int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		magma_desc_t *	L,
		int *	IPIV,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_zgesv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N matrix and X and B are N-by-NRHS matrices. The tile LU decomposition with partial tile pivoting and row interchanges is used to factor A. The factored form of A is then used to solve the system of equations A * X = B.

Parameters:

[in]	N	The number of linear equations, i.e., the order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in,out]	A	On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK).
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[out]	L	On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations.
[out]	IPIV	On exit, the pivot indices that define the permutations (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value
>0	if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.

See also:

MAGMA_zgesv_Tile

MAGMA_zgesv_Tile_Async

MAGMA_cgesv

MAGMA_dgesv

MAGMA_sgesv

MAGMA_zcgesv

Definition at line 76 of file zgesv.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, MAGMA_IB, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, MAGMA_zgesv_Tile_Async(), magma_zooplap2tile, magma_zooptile2lap, max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, IB, IBNB, NT;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_error("MAGMA_zgesv", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (N < 0) {
        magma_error("MAGMA_zgesv", "illegal value of N");
        return -1;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_zgesv", "illegal value of NRHS");
        return -2;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zgesv", "illegal value of LDA");
        return -4;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_zgesv", "illegal value of LDB");
        return -8;
    }
    /* Quick return */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB && IB depending on M, N && NRHS; Set NBNB */
    /* status = plasma_tune(PLASMA_FUNC_ZGESV, N, N, NRHS); */
    /* if (status != PLASMA_SUCCESS) { */
    /*     plasma_error("PLASMA_zgesv", "plasma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB    = MAGMA_NB;
    IB    = MAGMA_IB;
    IBNB  = IB*NB;
    NT    = (N%NB==0) ? (N/NB) : (N/NB+1);

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   , magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_zgesv_Tile_Async(&descA, L, IPIV, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descA, A, NB, NB, LDA, N    );
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N    ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */
    
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgesv_Tile	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B
	)

MAGMA_zgesv_Tile - Solves a system of linear equations using the tile LU factorization. Tile equivalent of MAGMA_zgetrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in,out]	A	On entry, the N-by-N coefficient matrix A. On exit, the tile L and U factors from the factorization (not equivalent to LAPACK).
[in,out]	L	On exit, auxiliary factorization data, related to the tile L factor, necessary to solve the system of equations.
[out]	IPIV	On exit, the pivot indices that define the permutations (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
>0	if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, so the solution could not be computed.

See also:

MAGMA_zgesv

MAGMA_zgesv_Tile_Async

MAGMA_cgesv_Tile

MAGMA_dgesv_Tile

MAGMA_sgesv_Tile

MAGMA_zcgesv_Tile

Definition at line 200 of file zgesv.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zgesv_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgesv_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zgesv_Tile_Async(A, L, IPIV, B, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( L );
    morse_desc_getoncpu( B );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgesv_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zgesv_Tile_Async - Solves a system of linear equations using the tile LU factorization. Non-blocking equivalent of MAGMA_zgesv_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zgesv

MAGMA_zgesv_Tile

MAGMA_cgesv_Tile_Async

MAGMA_dgesv_Tile_Async

MAGMA_sgesv_Tile_Async

MAGMA_zcgesv_Tile_Async

Definition at line 252 of file zgesv.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzgetrf(), magma_pztrsm(), magma_pztrsmpl(), magma_request_fail(), MAGMA_SUCCESS, plasma_memzero(), magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descL = L->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgesv_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zgesv_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zgesv_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgesv_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( L ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgesv_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgesv_Tile", "invalid third descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_zgesv_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
/*
    if (min(N, NRHS) == 0)
        return PLASMA_SUCCESS;
*/
    /* Clear IPIV and Lbdl */
    plasma_memzero(IPIV,      descA.mt*descA.nt*descA.nb,          PlasmaInteger);
    plasma_memzero(descL.mat, descL.mt*descL.nt*descL.mb*descL.nb, PlasmaComplexDouble);

    magma_pzgetrf( A, L, IPIV, sequence, request);
    magma_pztrsmpl(A, B, L, IPIV, sequence, request);
    magma_pztrsm( PlasmaLeft, PlasmaUpper, PlasmaNoTrans, PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgetmi	(	int	m,
		int	n,
		PLASMA_Complex64_t *	A,
		PLASMA_enum	fin,
		int	mb,
		int	nb
	)

int MAGMA_zgetmi_Async	(	int	m,
		int	n,
		PLASMA_Complex64_t *	A,
		PLASMA_enum	f_in,
		int	mb,
		int	inb,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zgetrf	(	int	M,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		magma_desc_t *	L,
		int *	IPIV
	)

MAGMA_zgetrf - Computes an LU factorization of a general M-by-N matrix A using the tile LU algorithm with partial tile pivoting with row interchanges.

Parameters:

[in]	M	The number of rows of the matrix A. M >= 0.
[in]	N	The number of columns of the matrix A. N >= 0.
[in,out]	A	On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[out]	L	On exit, auxiliary factorization data, related to the tile L factor, required by MAGMA_zgetrs to solve the system of equations.
[out]	IPIV	The pivot indices that define the permutations (not equivalent to LAPACK).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value
>0	if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

See also:

MAGMA_zgetrf_Tile

MAGMA_zgetrf_Tile_Async

MAGMA_cgetrf

MAGMA_dgetrf

MAGMA_sgetrf

MAGMA_zgetrs

Definition at line 67 of file zgetrf.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_IB, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, MAGMA_zgetrf_Tile_Async(), magma_zooplap2tile, magma_zooptile2lap, max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, IB, IBNB, MT, NT;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrf", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (M < 0) {
        magma_error("MAGMA_zgetrf", "illegal value of M");
        return -1;
    }
    if (N < 0) {
        magma_error("MAGMA_zgetrf", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, M)) {
        magma_error("MAGMA_zgetrf", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (min(M, N) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB && IB depending on M, N && NRHS; Set NBNBSIZE */
    /* status = plasma_tune(PLASMA_FUNC_ZGESV, M, N, 0); */
    /* if (status != PLASMA_SUCCESS) { */
    /*     plasma_error("PLASMA_zgetrf", "plasma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB   = MAGMA_NB;
    IB   = MAGMA_IB;
    IBNB = IB*NB;
    MT   = (M%NB==0) ? (M/NB) : (M/NB+1);
    NT   = (N%NB==0) ? (N/NB) : (N/NB+1);

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N, magma_desc_mat_free(&(descA)) );
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N); */
    /* } */

    /* Call the tile interface */
    MAGMA_zgetrf_Tile_Async(&descA, L, IPIV, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descA, A, NB, NB, LDA, N );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgetrf_Tile	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV
	)

MAGMA_zgetrf_Tile - Computes the tile LU factorization of a matrix. Tile equivalent of MAGMA_zgetrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in,out]	A	On entry, the M-by-N matrix to be factored. On exit, the tile factors L and U from the factorization.
[out]	L	On exit, auxiliary factorization data, related to the tile L factor, required by MAGMA_zgetrs to solve the system of equations.
[out]	IPIV	The pivot indices that define the permutations (not equivalent to LAPACK).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
>0	if i, U(i,i) is exactly zero. The factorization has been completed, but the factor U is exactly singular, and division by zero will occur if it is used to solve a system of equations.

See also:

MAGMA_zgetrf

MAGMA_zgetrf_Tile_Async

MAGMA_cgetrf_Tile

MAGMA_dgetrf_Tile

MAGMA_sgetrf_Tile

MAGMA_zgetrs_Tile

Definition at line 180 of file zgetrf.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zgetrf_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zgetrf_Tile_Async(A, L, IPIV, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( L );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgetrf_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zgetrf_Tile_Async - Computes the tile LU factorization of a matrix. Non-blocking equivalent of MAGMA_zgetrf_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zgetrf

MAGMA_zgetrf_Tile

MAGMA_cgetrf_Tile_Async

MAGMA_dgetrf_Tile_Async

MAGMA_sgetrf_Tile_Async

MAGMA_zgetrs_Tile_Async

Definition at line 230 of file zgetrf.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzgetrf(), magma_request_fail(), MAGMA_SUCCESS, plasma_memzero(), magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descL = L->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zgetrf_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zgetrf_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgetrf_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( L ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgetrf_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zgetrf_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
/*
    if (min(M, N) == 0)
        return MAGMA_SUCCESS;
*/
    /* Clear IPIV and Lbdl */
    plasma_memzero(IPIV,      descA.mt*descA.nt*descA.nb, PlasmaInteger);
    plasma_memzero(descL.mat, descL.lm*descL.ln,          PlasmaComplexDouble);

    magma_pzgetrf( A, L, IPIV, sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgetrs	(	PLASMA_enum	trans,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		magma_desc_t *	L,
		int *	IPIV,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_zgetrs - Solves a system of linear equations A * X = B, with a general N-by-N matrix A using the tile LU factorization computed by MAGMA_zgetrf.

Parameters:

[in]	trans	Intended to specify the the form of the system of equations: = PlasmaNoTrans: A * X = B (No transpose) = PlasmaTrans: A**T * X = B (Transpose) = PlasmaConjTrans: A**H * X = B (Conjugate transpose) Currently only PlasmaNoTrans is supported.
[in]	N	The order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in]	A	The tile factors L and U from the factorization, computed by MAGMA_zgetrf.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[in]	L	Auxiliary factorization data, related to the tile L factor, computed by MAGMA_zgetrf.
[in]	IPIV	The pivot indices from MAGMA_zgetrf (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS

successful exit

Returns:

<0 if -i, the i-th argument had an illegal value

See also:

MAGMA_zgetrs_Tile

MAGMA_zgetrs_Tile_Async

MAGMA_cgetrs

MAGMA_dgetrs

MAGMA_sgetrs

MAGMA_zgetrf

Definition at line 75 of file zgetrs.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_NOT_SUPPORTED, magma_error, magma_fatal_error, MAGMA_IB, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, MAGMA_zgetrs_Tile_Async(), magma_zooplap2tile, magma_zooptile2lap, max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, IB, IBNB, NT;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrs", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (trans != PlasmaNoTrans) {
        magma_error("MAGMA_zgetrs", "only PlasmaNoTrans supported");
        return MAGMA_ERR_NOT_SUPPORTED;
    }
    if (N < 0) {
        magma_error("MAGMA_zgetrs", "illegal value of N");
        return -2;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_zgetrs", "illegal value of NRHS");
        return -3;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zgetrs", "illegal value of LDA");
        return -5;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_zgetrs", "illegal value of LDB");
        return -9;
    }
    /* Quick return */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB && IB depending on N && NRHS; Set NBNBSIZE */
    /* status = magma_tune(PLASMA_FUNC_ZGESV, N, N, NRHS); */
    /* if (status != PLASMA_SUCCESS) { */
    /*     plasma_error("PLASMA_zgetrs", "plasma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB    = MAGMA_NB;
    IB    = MAGMA_IB;
    IBNB  = IB*NB;
    NT    = (N%NB==0) ? (N/NB) : (N/NB+1);

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   , magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_zgetrs_Tile_Async(&descA, L, IPIV, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N    ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zgetrs_Tile	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B
	)

MAGMA_zgetrs_Tile - Solves a system of linear equations using previously computed LU factorization. Tile equivalent of MAGMA_zgetrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	A	The tile factors L and U from the factorization, computed by MAGMA_zgetrf.
[in]	L	Auxiliary factorization data, related to the tile L factor, computed by MAGMA_zgetrf.
[in]	IPIV	The pivot indices from MAGMA_zgetrf (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS matrix of right hand side matrix B. On exit, the solution matrix X.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zgetrs

MAGMA_zgetrs_Tile_Async

MAGMA_cgetrs_Tile

MAGMA_dgetrs_Tile

MAGMA_sgetrs_Tile

MAGMA_zgetrf_Tile

Definition at line 200 of file zgetrs.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zgetrs_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrs_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zgetrs_Tile_Async(A, L, IPIV, B, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( L );
    morse_desc_getoncpu( B );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zgetrs_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zgetrs_Tile_Async - Solves a system of linear equations using previously computed LU factorization. Non-blocking equivalent of MAGMA_zgetrs_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zgetrs

MAGMA_zgetrs_Tile

MAGMA_cgetrs_Tile_Async

MAGMA_dgetrs_Tile_Async

MAGMA_sgetrs_Tile_Async

MAGMA_zgetrf_Tile_Async

Definition at line 252 of file zgetrs.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pztrsm(), magma_pztrsmpl(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zgetrs_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zgetrs_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zgetrs_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgetrs_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( L ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgetrs_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zgetrs_Tile", "invalid third descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_zgetrs_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
/*
    if (min(N, NRHS) == 0)
        return PLASMA_SUCCESS;
*/
    magma_pztrsmpl(A, B, L, IPIV, sequence, request);
    magma_pztrsm( PlasmaLeft, PlasmaUpper, PlasmaNoTrans, PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zhemm	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		int	M,
		int	N,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB,
		PLASMA_Complex64_t	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zhemm_Tile	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C
	)

int MAGMA_zhemm_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zher2k	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		int	N,
		int	K,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB,
		double	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zher2k_Tile	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		double	beta,
		magma_desc_t *	C
	)

int MAGMA_zher2k_Tile_Async	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		double	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zherk	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		int	N,
		int	K,
		double	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		double	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zherk_Tile	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		double	alpha,
		magma_desc_t *	A,
		double	beta,
		magma_desc_t *	C
	)

int MAGMA_zherk_Tile_Async	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		double	alpha,
		magma_desc_t *	A,
		double	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

double MAGMA_zlange	(	PLASMA_enum	norm,
		int	M,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		double *	work
	)

double MAGMA_zlange_Tile	(	PLASMA_enum	norm,
		magma_desc_t *	A,
		double *	work
	)

int MAGMA_zlange_Tile_Async	(	PLASMA_enum	norm,
		magma_desc_t *	A,
		double *	work,
		double *	value,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

double MAGMA_zlanhe	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		double *	work
	)

double MAGMA_zlanhe_Tile	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		magma_desc_t *	A,
		double *	work
	)

int MAGMA_zlanhe_Tile_Async	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		magma_desc_t *	A,
		double *	work,
		double *	value,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

double MAGMA_zlansy	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		double *	work
	)

double MAGMA_zlansy_Tile	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		magma_desc_t *	A,
		double *	work
	)

int MAGMA_zlansy_Tile_Async	(	PLASMA_enum	norm,
		PLASMA_enum	uplo,
		magma_desc_t *	A,
		double *	work,
		double *	value,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zLapack_to_Tile	(	PLASMA_Complex64_t *	Af77,
		int	LDA,
		magma_desc_t *	A
	)

---

Auxiliary function prototypes

MAGMA_zLapack_to_Tile - Conversion from LAPACK layout to tile layout.

Parameters:

[in]	Af77	LAPACK matrix.
[in]	LDA	The leading dimension of the matrix Af77.
[in,out]	A	Descriptor of the MAGMA matrix in tile layout. If MAGMA_TRANSLATION_MODE is set to MAGMA_INPLACE, A->mat is not used and set to Af77 when returns, else if MAGMA_TRANSLATION_MODE is set to MAGMA_OUTOFPLACE, A->mat has to be allocated before.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zLapack_to_Tile_Async

MAGMA_zTile_to_Lapack

MAGMA_cLapack_to_Tile

MAGMA_dLapack_to_Tile

MAGMA_sLapack_to_Tile

Definition at line 53 of file ztile.c.

References magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, magma_pzlapack_to_tile(), magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zLapack_to_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check descriptor for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zLapack_to_Tile", "invalid descriptor");
        return MAGMA_ERR_ILLEGAL_VALUE;
    }
    magma_sequence_create(magma, &sequence);

    magma_pzlapack_to_tile( Af77, LDA, A, sequence, &request);

    morse_barrier( magma );
    morse_desc_getoncpu( A );

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zLapack_to_Tile_Async	(	PLASMA_Complex64_t *	Af77,
		int	LDA,
		magma_desc_t *	A,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zLapack_to_Tile_Async - Conversion from LAPACK layout to tile layout. Non-blocking equivalent of MAGMA_zLapack_to_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	Af77	LAPACK matrix.
[in]	LDA	The leading dimension of the matrix Af77.
[in,out]	A	Descriptor of the MAGMA matrix in tile layout. If MAGMA_TRANSLATION_MODE is set to MAGMA_INPLACE, A->mat is not used and set to Af77 when returns, else if MAGMA_TRANSLATION_MODE is set to MAGMA_OUTOFPLACE, A->mat has to be allocated before.
[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zTile_to_Lapack_Async

MAGMA_zLapack_to_Tile

MAGMA_cLapack_to_Tile_Async

MAGMA_dLapack_to_Tile_Async

MAGMA_sLapack_to_Tile_Async

Definition at line 123 of file ztile.c.

References magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, magma_pzlapack_to_tile(), and MAGMA_SUCCESS.

{
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zLapack_to_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check descriptor for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zLapack_to_Tile", "invalid descriptor");
        return MAGMA_ERR_ILLEGAL_VALUE;
    }

    magma_pzlapack_to_tile( Af77, LDA, A, sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

int MAGMA_zlauum	(	PLASMA_enum	uplo,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA
	)

int MAGMA_zlauum_Tile	(	PLASMA_enum	uplo,
		magma_desc_t *	A
	)

int MAGMA_zlauum_Tile_Async	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zplghe	(	double	bump,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		unsigned long long int	seed
	)

MAGMA_zplghe - Generate a random hermitian matrix by tiles.

Parameters:

[in]	bump	The value to add to the diagonal to be sure to have a positive definite matrix.
[in]	N	The order of the matrix A. N >= 0.
[out]	A	On exit, The random hermitian matrix A generated.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_zplghe_Tile

MAGMA_zplghe_Tile_Async

MAGMA_cplghe

MAGMA_dplghe

MAGMA_splghe

MAGMA_zplrnt

MAGMA_zplgsy

Definition at line 59 of file zplghe.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zdesc_alloc, magma_zooptile2lap, MAGMA_zplghe_Tile_Async(), max, morse_barrier(), and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplghe", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (N < 0) {
        magma_error("MAGMA_zplghe", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zplghe", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (max(0, N) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZGEMM, N, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zplghe", "magma_tune() failed"); */
    /*     return status; */
    /* } */
    
    /* Set NT */
    NB = MAGMA_NB;
    magma_sequence_create(magma, &sequence);
    
    magma_zdesc_alloc( descA, NB, NB, LDA, N, 0, 0, N, N, magma_desc_mat_free(&(descA)) );

    /* Call the tile interface */
    MAGMA_zplghe_Tile_Async( bump, &descA, seed, sequence, &request );

    morse_barrier( magma );
    magma_zooptile2lap( descA, A, NB, NB, LDA, N );
    morse_barrier( magma );

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zplghe_Tile	(	double	bump,
		magma_desc_t *	A,
		unsigned long long int	seed
	)

MAGMA_zplghe_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of MAGMA_zplghe(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	bump	The value to add to the diagonal to be sure to have a positive definite matrix.
[in]	A	On exit, The random hermitian matrix A generated.
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zplghe

MAGMA_zplghe_Tile_Async

MAGMA_cplghe_Tile

MAGMA_dplghe_Tile

MAGMA_splghe_Tile

MAGMA_zplrnt_Tile

MAGMA_zplgsy_Tile

Definition at line 152 of file zplghe.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zplghe_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplghe_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zplghe_Tile_Async( bump, A, seed, sequence, &request );
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zplghe_Tile_Async	(	double	bump,
		magma_desc_t *	A,
		unsigned long long int	seed,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zplghe_Tile_Async - Generate a random hermitian matrix by tiles. Non-blocking equivalent of MAGMA_zplghe_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zplghe

MAGMA_zplghe_Tile

MAGMA_cplghe_Tile_Async

MAGMA_dplghe_Tile_Async

MAGMA_splghe_Tile_Async

MAGMA_zplghe_Tile_Async

MAGMA_zplgsy_Tile_Async

Definition at line 203 of file zplghe.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzplghe(), magma_request_fail(), MAGMA_SUCCESS, min, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplghe_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zplghe_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zplghe_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zplghe_Tile", "invalid descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zplghe_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }

    /* Quick return */
    if (min( descA.m, descA.n ) == 0)
        return MAGMA_SUCCESS;

    magma_pzplghe( bump, A, seed, sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zplgsy	(	PLASMA_Complex64_t	bump,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		unsigned long long int	seed
	)

MAGMA_zplgsy - Generate a random symmetric matrix by tiles.

Parameters:

[in]	bump	The value to add to the diagonal to be sure to have a positive definite matrix.
[in]	N	The order of the matrix A. N >= 0.
[out]	A	On exit, The random symmetric matrix A generated.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_zplgsy_Tile

MAGMA_zplgsy_Tile_Async

MAGMA_cplgsy

MAGMA_dplgsy

MAGMA_splgsy

MAGMA_zplrnt

MAGMA_zplghe

Definition at line 59 of file zplgsy.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zdesc_alloc, magma_zooptile2lap, MAGMA_zplgsy_Tile_Async(), max, morse_barrier(), and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplgsy", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (N < 0) {
        magma_error("MAGMA_zplgsy", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zplgsy", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (max(0, N) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZGEMM, N, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zplgsy", "magma_tune() failed"); */
    /*     return status; */
    /* } */
    
    /* Set NT */
    NB = MAGMA_NB;
    magma_sequence_create(magma, &sequence);
    
    magma_zdesc_alloc( descA, NB, NB, LDA, N, 0, 0, N, N, magma_desc_mat_free(&(descA)) );

    /* Call the tile interface */
    MAGMA_zplgsy_Tile_Async( bump, &descA, seed, sequence, &request );

    morse_barrier( magma );
    magma_zooptile2lap( descA, A, NB, NB, LDA, N );
    morse_barrier( magma );

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);

    return status;
}

Here is the call graph for this function:

int MAGMA_zplgsy_Tile	(	PLASMA_Complex64_t	bump,
		magma_desc_t *	A,
		unsigned long long int	seed
	)

MAGMA_zplgsy_Tile - Generate a random hermitian matrix by tiles. Tile equivalent of MAGMA_zplgsy(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	bump	The value to add to the diagonal to be sure to have a positive definite matrix.
[in]	A	On exit, The random hermitian matrix A generated.
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zplgsy

MAGMA_zplgsy_Tile_Async

MAGMA_cplgsy_Tile

MAGMA_dplgsy_Tile

MAGMA_splgsy_Tile

MAGMA_zplrnt_Tile

MAGMA_zplgsy_Tile

Definition at line 152 of file zplgsy.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zplgsy_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplgsy_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zplgsy_Tile_Async( bump, A, seed, sequence, &request );
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_zplgsy_Tile_Async	(	PLASMA_Complex64_t	bump,
		magma_desc_t *	A,
		unsigned long long int	seed,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zplgsy_Tile_Async - Generate a random hermitian matrix by tiles. Non-blocking equivalent of MAGMA_zplgsy_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zplgsy

MAGMA_zplgsy_Tile

MAGMA_cplgsy_Tile_Async

MAGMA_dplgsy_Tile_Async

MAGMA_splgsy_Tile_Async

MAGMA_zplgsy_Tile_Async

MAGMA_zplgsy_Tile_Async

Definition at line 203 of file zplgsy.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzplgsy(), magma_request_fail(), MAGMA_SUCCESS, min, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplgsy_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zplgsy_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zplgsy_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zplgsy_Tile", "invalid descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zplgsy_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }

    /* Quick return */
    if (min( descA.m, descA.n ) == 0)
        return MAGMA_SUCCESS;

    magma_pzplgsy(bump, A, seed, sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zplrnt	(	int	M,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA,
		unsigned long long int	seed
	)

MAGMA_zplrnt - Generate a random matrix by tiles.

Parameters:

[in]	M	The number of rows of A.
[in]	N	The order of the matrix A. N >= 0.
[out]	A	On exit, The random matrix A generated.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_zplrnt_Tile

MAGMA_zplrnt_Tile_Async

MAGMA_cplrnt

MAGMA_dplrnt

MAGMA_splrnt

MAGMA_zplghe

MAGMA_zplgsy

Definition at line 58 of file zplrnt.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zdesc_alloc, magma_zooptile2lap, MAGMA_zplrnt_Tile_Async(), max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplrnt", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (M < 0) {
        magma_error("MAGMA_zplrnt", "illegal value of M");
        return -1;
    }
    if (N < 0) {
        magma_error("MAGMA_zplrnt", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, M)) {
        magma_error("MAGMA_zplrnt", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (min(M, N) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZGEMM, M, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zplrnt", "magma_tune() failed"); */
    /*     return status; */
    /* } */
    
    /* Set NT */
    NB = MAGMA_NB;
    magma_sequence_create(magma, &sequence);

    magma_zdesc_alloc( descA, NB, NB, LDA, N, 0, 0, N, N, magma_desc_mat_free(&(descA)) );

    /* Call the tile interface */
    MAGMA_zplrnt_Tile_Async( &descA, seed, sequence, &request );

    morse_barrier( magma );
    
    magma_zooptile2lap( descA, A, NB, NB, LDA, N );
    morse_barrier( magma );

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);

    return status;
}

Here is the call graph for this function:

int MAGMA_zplrnt_Tile	(	magma_desc_t *	A,
		unsigned long long int	seed
	)

MAGMA_zplrnt_Tile - Generate a random matrix by tiles. Tile equivalent of MAGMA_zplrnt(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	A	On exit, The random matrix A generated.
[in]	seed	The seed used in the random generation.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zplrnt

MAGMA_zplrnt_Tile_Async

MAGMA_cplrnt_Tile

MAGMA_dplrnt_Tile

MAGMA_splrnt_Tile

MAGMA_zplghe_Tile

MAGMA_zplgsy_Tile

Definition at line 152 of file zplrnt.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zplrnt_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplrnt_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zplrnt_Tile_Async( A, seed, sequence, &request );
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zplrnt_Tile_Async	(	magma_desc_t *	A,
		unsigned long long int	seed,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zplrnt_Tile_Async - Generate a random matrix by tiles. Non-blocking equivalent of MAGMA_zplrnt_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zplrnt

MAGMA_zplrnt_Tile

MAGMA_cplrnt_Tile_Async

MAGMA_dplrnt_Tile_Async

MAGMA_splrnt_Tile_Async

MAGMA_zplghe_Tile_Async

MAGMA_zplgsy_Tile_Async

Definition at line 203 of file zplrnt.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzplrnt(), magma_request_fail(), MAGMA_SUCCESS, min, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zplrnt_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zplrnt_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zplrnt_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zplrnt_Tile", "invalid descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zplrnt_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }

    /* Quick return */
    if (min( descA.m, descA.n ) == 0)
        return MAGMA_SUCCESS;

    magma_pzplrnt( A, seed, sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zposv	(	PLASMA_enum	uplo,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_zposv - Computes the solution to a system of linear equations A * X = B, where A is an N-by-N symmetric positive definite (or Hermitian positive definite in the complex case) matrix and X and B are N-by-NRHS matrices. The Cholesky decomposition is used to factor A as

where U is an upper triangular matrix and L is a lower triangular matrix. The factored form of A is then used to solve the system of equations A * X = B.

Parameters:

[in]	uplo	Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	N	The number of linear equations, i.e., the order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in,out]	A	On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value
>0	if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See also:

MAGMA_zposv_Tile

MAGMA_zposv_Tile_Async

MAGMA_cposv

MAGMA_dposv

MAGMA_sposv

Definition at line 82 of file zposv.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zooplap2tile, magma_zooptile2lap, MAGMA_zposv_Tile_Async(), max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zposv", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zposv", "illegal value of uplo");
        return -1;
    }
    if (N < 0) {
        magma_error("MAGMA_zposv", "illegal value of N");
        return -2;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_zposv", "illegal value of NRHS");
        return -3;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zposv", "illegal value of LDA");
        return -5;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_zposv", "illegal value of LDB");
        return -7;
    }
    /* Quick return - currently NOT equivalent to LAPACK's
     * LAPACK does not have such check for DPOSV */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNBSIZE */
    /* status = magma_tune(MAGMA_FUNC_ZPOSV, N, N, NRHS); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zposv", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB    = MAGMA_NB;

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   , magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_zposv_Tile_Async(uplo, &descA, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descA, A, NB, NB, LDA, N    );
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N    ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */
    
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zposv_Tile	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_desc_t *	B
	)

MAGMA_zposv_Tile - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Tile equivalent of MAGMA_zposv(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	uplo	Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in,out]	A	On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
>0	if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See also:

MAGMA_zposv

MAGMA_zposv_Tile_Async

MAGMA_cposv_Tile

MAGMA_dposv_Tile

MAGMA_sposv_Tile

Definition at line 212 of file zposv.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zposv_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zposv_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zposv_Tile_Async(uplo, A, B, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( B );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zposv_Tile_Async	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zposv_Tile_Async - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Non-blocking equivalent of MAGMA_zposv_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zposv

MAGMA_zposv_Tile

MAGMA_cposv_Tile_Async

MAGMA_dposv_Tile_Async

MAGMA_sposv_Tile_Async

Definition at line 262 of file zposv.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzpotrf(), magma_pztrsm(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zposv_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zposv_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zposv_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zposv_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zposv_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_zposv_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zposv_Tile", "illegal value of uplo");
        return magma_request_fail(sequence, request, -1);
    }
    /* Quick return - currently NOT equivalent to LAPACK's
     * LAPACK does not have such check for DPOSV */
/*
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;
*/
    magma_pzpotrf( uplo, A, sequence, request);
    magma_pztrsm( PlasmaLeft, uplo,
                  uplo == PlasmaUpper ? PlasmaConjTrans : PlasmaNoTrans,
                  PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    magma_pztrsm( PlasmaLeft, uplo,
                  uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaConjTrans,
                  PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotrf	(	PLASMA_enum	uplo,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA
	)

MAGMA_zpotrf - Computes the Cholesky factorization of a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A. The factorization has the form

where U is an upper triangular matrix and L is a lower triangular matrix.

Parameters:

[in]	uplo	= PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	N	The order of the matrix A. N >= 0.
[in,out]	A	On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value
>0	if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See also:

MAGMA_zpotrf_Tile

MAGMA_zpotrf_Tile_Async

MAGMA_cpotrf

MAGMA_dpotrf

MAGMA_spotrf

MAGMA_zpotrs

Definition at line 70 of file zpotrf.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zooplap2tile, magma_zooptile2lap, MAGMA_zpotrf_Tile_Async(), max, morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrf", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zpotrf", "illegal value of uplo");
        return -1;
    }
    if (N < 0) {
         magma_error("MAGMA_zpotrf", "illegal value of N");
        return -2;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zpotrf", "illegal value of LDA");
        return -4;
    }
    /* Quick return */
    if (max(N, 0) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N & NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZPOSV, N, N, 0); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zpotrf", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT */
    NB   = MAGMA_NB;

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N, magma_desc_mat_free(&(descA)) );
    /* } else { */
    /*     magma_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N); */
    /* } */

    /* Call the tile interface */
    MAGMA_zpotrf_Tile_Async(uplo, &descA, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descA, A, NB, NB, LDA, N );
        morse_barrier( magma );
        morse_desc_getoncpu( &descA );
        magma_desc_mat_free(&descA);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N ); */
    /*     morse_barrier( magma ); */
    /* } */
        
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);

    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotrf_Tile	(	PLASMA_enum	uplo,
		magma_desc_t *	A
	)

MAGMA_zpotrf_Tile - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Tile equivalent of MAGMA_zpotrf(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	uplo	= MagmaUpper: Upper triangle of A is stored; = MagmaLower: Lower triangle of A is stored.
[in]	A	On entry, the symmetric positive definite (or Hermitian) matrix A. If uplo = MagmaUpper, the leading N-by-N upper triangular part of A contains the upper triangular part of the matrix A, and the strictly lower triangular part of A is not referenced. If UPLO = 'L', the leading N-by-N lower triangular part of A contains the lower triangular part of the matrix A, and the strictly upper triangular part of A is not referenced. On exit, if return value = 0, the factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H.

Returns:

Return values:

MAGMA_SUCCESS	successful exit
>0	if i, the leading minor of order i of A is not positive definite, so the factorization could not be completed, and the solution has not been computed.

See also:

MAGMA_zpotrf

MAGMA_zpotrf_Tile_Async

MAGMA_cpotrf_Tile

MAGMA_dpotrf_Tile

MAGMA_spotrf_Tile

MAGMA_zpotrs_Tile

Definition at line 184 of file zpotrf.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zpotrf_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zpotrf_Tile_Async(uplo, A, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotrf_Tile_Async	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zpotrf_Tile_Async - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Non-blocking equivalent of MAGMA_zpotrf_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zpotrf

MAGMA_zpotrf_Tile

MAGMA_cpotrf_Tile_Async

MAGMA_dpotrf_Tile_Async

MAGMA_spotrf_Tile_Async

MAGMA_zpotrs_Tile_Async

Definition at line 234 of file zpotrf.c.

References magma_desc_s::desc, magma_context_self(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pzpotrf(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrf_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zpotrf_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zpotrf_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    /* if (magma_desc_check( A ) != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zpotrf_Tile", "invalid descriptor"); */
    /*     return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE); */
    /* } */
    /* Check input arguments */
    if (descA.nb != descA.mb) {
        magma_error("MAGMA_zpotrf_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zpotrf_Tile", "illegal value of uplo");
        return magma_request_fail(sequence, request, -1);
    }
    /* Quick return */
/*
    if (max(N, 0) == 0)
        return MAGMA_SUCCESS;
*/
    magma_pzpotrf(uplo, A, sequence, request);

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotri	(	PLASMA_enum	uplo,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA
	)

int MAGMA_zpotri_Tile	(	PLASMA_enum	uplo,
		magma_desc_t *	A
	)

int MAGMA_zpotri_Tile_Async	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zpotrs	(	PLASMA_enum	uplo,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_zpotrs - Solves a system of linear equations A * X = B with a symmetric positive definite (or Hermitian positive definite in the complex case) matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by MAGMA_zpotrf.

Parameters:

[in]	uplo	= PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	N	The order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in]	A	The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by PLASMA_zpotrf.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_zpotrs_Tile

MAGMA_zpotrs_Tile_Async

MAGMA_cpotrs

MAGMA_dpotrs

MAGMA_spotrs

MAGMA_zpotrf

Definition at line 67 of file zpotrs.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zooplap2tile, magma_zooptile2lap, MAGMA_zpotrs_Tile_Async(), max, min, morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    int NB;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrs", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zpotrs", "illegal value of uplo");
        return -1;
    }
    if (N < 0) {
        magma_error("MAGMA_zpotrs", "illegal value of N");
        return -2;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_zpotrs", "illegal value of NRHS");
        return -3;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_zpotrs", "illegal value of LDA");
        return -5;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_zpotrs", "illegal value of LDB");
        return -7;
    }
    /* Quick return */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZPOSV, N, N, NRHS); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_zpotrs", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB    = MAGMA_NB;

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   , magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_zpotrs_Tile_Async(uplo, &descA, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        morse_desc_getoncpu( &descB );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N    ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */
    
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotrs_Tile	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_desc_t *	B
	)

MAGMA_zpotrs_Tile - Solves a system of linear equations using previously computed Cholesky factorization. Tile equivalent of MAGMA_zpotrs(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	uplo	= PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	A	The triangular factor U or L from the Cholesky factorization A = U**H*U or A = L*L**H, computed by MAGMA_zpotrf.
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zpotrs

MAGMA_zpotrs_Tile_Async

MAGMA_cpotrs_Tile

MAGMA_dpotrs_Tile

MAGMA_spotrs_Tile

MAGMA_zpotrf_Tile

Definition at line 188 of file zpotrs.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_zpotrs_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrs_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_zpotrs_Tile_Async(uplo, A, B, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( B );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zpotrs_Tile_Async	(	PLASMA_enum	uplo,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zpotrs_Tile_Async - Solves a system of linear equations using previously computed Cholesky factorization. Non-blocking equivalent of MAGMA_zpotrs_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zpotrs

MAGMA_zpotrs_Tile

MAGMA_cpotrs_Tile_Async

MAGMA_dpotrs_Tile_Async

MAGMA_spotrs_Tile_Async

MAGMA_zpotrf_Tile_Async

Definition at line 239 of file zpotrs.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pztrsm(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zpotrs_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_zpotrs_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_zpotrs_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zpotrs_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zpotrs_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_zpotrs_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_zpotrs_Tile", "illegal value of uplo");
        return magma_request_fail(sequence, request, -1);
    }
    /* Quick return */
/*
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;
*/

    magma_pztrsm( PlasmaLeft, uplo,
                  uplo == PlasmaUpper ? PlasmaConjTrans : PlasmaNoTrans,
                  PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    magma_pztrsm( PlasmaLeft, uplo,
                  uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaConjTrans,
                  PlasmaNonUnit,
                  1.0, A, B,
                  sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zsymm	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		int	M,
		int	N,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB,
		PLASMA_Complex64_t	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zsymm_Tile	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C
	)

int MAGMA_zsymm_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zsyr2k	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		int	N,
		int	K,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB,
		PLASMA_Complex64_t	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zsyr2k_Tile	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C
	)

int MAGMA_zsyr2k_Tile_Async	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zsyrk	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		int	N,
		int	K,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t	beta,
		PLASMA_Complex64_t *	C,
		int	LDC
	)

int MAGMA_zsyrk_Tile	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C
	)

int MAGMA_zsyrk_Tile_Async	(	PLASMA_enum	uplo,
		PLASMA_enum	trans,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		PLASMA_Complex64_t	beta,
		magma_desc_t *	C,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zTile_to_Lapack	(	magma_desc_t *	A,
		PLASMA_Complex64_t *	Af77,
		int	LDA
	)

MAGMA_Tile_to_Lapack - Conversion from tile layout to LAPACK layout.

Parameters:

[in]	A	Descriptor of the MAGMA matrix in tile layout.
[in,out]	Af77	LAPACK matrix. If MAGMA_TRANSLATION_MODE is set to MAGMA_INPLACE, Af77 has to be A->mat, else if MAGMA_TRANSLATION_MODE is set to MAGMA_OUTOFPLACE, Af77 has to be allocated before.
[in]	LDA	The leading dimension of the matrix Af77.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_zTile_to_Lapack_Async

MAGMA_zLapack_to_Tile

MAGMA_cTile_to_Lapack

MAGMA_dTile_to_Lapack

MAGMA_sTile_to_Lapack

Definition at line 179 of file ztile.c.

References magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, magma_pztile_to_lapack(), magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zTile_to_Lapack", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check descriptor for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zTile_to_Lapack", "invalid descriptor");
        return MAGMA_ERR_ILLEGAL_VALUE;
    }
    magma_sequence_create(magma, &sequence);

    magma_pztile_to_lapack( A, Af77, LDA, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_zTile_to_Lapack_Async	(	magma_desc_t *	A,
		PLASMA_Complex64_t *	Af77,
		int	LDA,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_zTile_to_Lapack_Async - Conversion from LAPACK layout to tile layout. Non-blocking equivalent of MAGMA_zTile_to_Lapack(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	A	Descriptor of the MAGMA matrix in tile layout.
[in,out]	Af77	LAPACK matrix. If MAGMA_TRANSLATION_MODE is set to MAGMA_INPLACE, Af77 has to be A->mat, else if MAGMA_TRANSLATION_MODE is set to MAGMA_OUTOFPLACE, Af77 has to be allocated before.
[in]	LDA	The leading dimension of the matrix Af77.
[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_zLapack_to_Tile_Async

MAGMA_zTile_to_Lapack

MAGMA_cTile_to_Lapack_Async

MAGMA_dTile_to_Lapack_Async

MAGMA_sTile_to_Lapack_Async

Definition at line 247 of file ztile.c.

References magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, magma_pztile_to_lapack(), and MAGMA_SUCCESS.

{
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_zTile_to_Lapack", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check descriptor for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_zTile_to_Lapack", "invalid descriptor");
        return MAGMA_ERR_ILLEGAL_VALUE;
    }

    magma_pztile_to_lapack( A, Af77, LDA, sequence, request );

    return MAGMA_SUCCESS;
}

Here is the call graph for this function:

int MAGMA_ztrmm	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_ztrmm_Tile	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B
	)

int MAGMA_ztrmm_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_ztrsm	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		int	N,
		int	NRHS,
		PLASMA_Complex64_t	alpha,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_ztrsm - Computes triangular solve A*X = B or X*A = B.

Parameters:

[in]	side	Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
[in]	uplo	Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	transA	Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
[in]	diag	Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
[in]	N	The order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in]	alpha	alpha specifies the scalar alpha.
[in]	A	The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

PLASMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_ztrsm_Tile

MAGMA_ztrsm_Tile_Async

MAGMA_ctrsm

MAGMA_dtrsm

MAGMA_strsm

Definition at line 88 of file ztrsm.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zooplap2tile, magma_zooptile2lap, MAGMA_ztrsm_Tile_Async(), max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, NA;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsm", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (side != PlasmaLeft && side != PlasmaRight) {
        magma_error("MAGMA_ztrsm", "illegal value of side");
        return -1;
    }
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_ztrsm", "illegal value of uplo");
        return -2;
    }
    if (transA != PlasmaConjTrans && transA != PlasmaNoTrans && transA != PlasmaTrans ) {
        magma_error("MAGMA_ztrsm", "illegal value of transA");
        return -3;
    }
    if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
        magma_error("MAGMA_ztrsm", "illegal value of diag");
        return -4;
    }
    if (N < 0) {
        magma_error("MAGMA_ztrsm", "illegal value of N");
        return -5;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_ztrsm", "illegal value of NRHS");
        return -6;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_ztrsm", "illegal value of LDA");
        return -8;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_ztrsm", "illegal value of LDB");
        return -10;
    }
    /* Quick return */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB depending on M, N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZPOSV, N, N, NRHS); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_ztrsm", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set NT && NTRHS */
    NB = MAGMA_NB;
    if (side == PlasmaLeft) {
      NA = N;
    } else {
      NA = NRHS;
    }

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, NA,   0, 0, NA, NA,   magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N,  NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, NA,   0, 0, NA, NA  ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N,  NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_ztrsm_Tile_Async(
        side, uplo, transA, diag, alpha, &descA, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, NA   ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_ztrsm_Tile	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B
	)

MAGMA_ztrsm_Tile - Computes triangular solve. Tile equivalent of MAGMA_ztrsm(). Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	side	Specifies whether A appears on the left or on the right of X: = PlasmaLeft: A*X = B = PlasmaRight: X*A = B
[in]	uplo	Specifies whether the matrix A is upper triangular or lower triangular: = PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]	transA	Specifies whether the matrix A is transposed, not transposed or conjugate transposed: = PlasmaNoTrans: A is transposed; = PlasmaTrans: A is not transposed; = PlasmaConjTrans: A is conjugate transposed.
[in]	diag	Specifies whether or not A is unit triangular: = PlasmaNonUnit: A is non unit; = PlasmaUnit: A us unit.
[in]	alpha	alpha specifies the scalar alpha.
[in]	A	The triangular matrix A. If uplo = PlasmaUpper, the leading N-by-N upper triangular part of the array A contains the upper triangular matrix, and the strictly lower triangular part of A is not referenced. If uplo = PlasmaLower, the leading N-by-N lower triangular part of the array A contains the lower triangular matrix, and the strictly upper triangular part of A is not referenced. If diag = PlasmaUnit, the diagonal elements of A are also not referenced and are assumed to be 1.
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:

PLASMA_SUCCESS

successful exit

See also:

MAGMA_ztrsm

MAGMA_ztrsm_Tile_Async

MAGMA_ctrsm_Tile

MAGMA_dtrsm_Tile

MAGMA_strsm_Tile

Definition at line 249 of file ztrsm.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_ztrsm_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsm_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_ztrsm_Tile_Async(side, uplo, transA, diag, alpha, A, B, sequence, &request);
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( B );
    morse_barrier( magma );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_ztrsm_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	uplo,
		PLASMA_enum	transA,
		PLASMA_enum	diag,
		PLASMA_Complex64_t	alpha,
		magma_desc_t *	A,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_ztrsm_Tile_Async - Computes triangular solve. Non-blocking equivalent of MAGMA_ztrsm_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_ztrsm

MAGMA_ztrsm_Tile

MAGMA_ctrsm_Tile_Async

MAGMA_dtrsm_Tile_Async

MAGMA_strsm_Tile_Async

Definition at line 300 of file ztrsm.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pztrsm(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsm_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_ztrsm_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_ztrsm_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_ztrsm_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_ztrsm_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_ztrsm_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (side != PlasmaLeft && side != PlasmaRight) {
        magma_error("MAGMA_ztrsm_Tile", "illegal value of side");
        return magma_request_fail(sequence, request, -1);
    }
    if (uplo != PlasmaUpper && uplo != PlasmaLower) {
        magma_error("MAGMA_ztrsm_Tile", "illegal value of uplo");
        return magma_request_fail(sequence, request, -2);
    }
    if (transA != PlasmaConjTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
        magma_error("MAGMA_ztrsm_Tile", "illegal value of transA");
        return magma_request_fail(sequence, request, -3);
    }
    if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
        magma_error("MAGMA_ztrsm_Tile", "illegal value of diag");
        return magma_request_fail(sequence, request, -4);
    }

    /* Quick return */
    magma_pztrsm( side, uplo, transA, diag,
                  alpha, A, B,
                  sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_ztrsmpl	(	int	N,
		int	NRHS,
		PLASMA_Complex64_t *	A,
		int	LDA,
		magma_desc_t *	L,
		int *	IPIV,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

MAGMA_ztrsmpl - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix.

Parameters:

[in]	N	The order of the matrix A. N >= 0.
[in]	NRHS	The number of right hand sides, i.e., the number of columns of the matrix B. NRHS >= 0.
[in]	A	The tile factor L from the factorization, computed by MAGMA_zgetrf.
[in]	LDA	The leading dimension of the array A. LDA >= max(1,N).
[in]	L	Auxiliary factorization data, related to the tile L factor, computed by MAGMA_zgetrf.
[in]	IPIV	The pivot indices from MAGMA_zgetrf (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.
[in]	LDB	The leading dimension of the array B. LDB >= max(1,N).

Returns:

Return values:

MAGMA_SUCCESS	successful exit
<0	if -i, the i-th argument had an illegal value

See also:

MAGMA_ztrsmpl_Tile

MAGMA_ztrsmpl_Tile_Async

MAGMA_ctrsmpl

MAGMA_dtrsmpl

MAGMA_strsmpl

MAGMA_zgetrf

Definition at line 67 of file ztrsmpl.c.

References magma_context_self(), magma_desc_mat_free(), MAGMA_ERR_NOT_INITIALIZED, magma_error, magma_fatal_error, MAGMA_IB, MAGMA_NB, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_SUCCESS, magma_zooplap2tile, magma_zooptile2lap, MAGMA_ztrsmpl_Tile_Async(), max, min, morse_barrier(), and magma_sequence_s::status.

{
    int NB, IB, IBNB, NT;
    int status;
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    magma_desc_t descA, descB;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsmpl", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    /* Check input arguments */
    if (N < 0) {
        magma_error("MAGMA_ztrsmpl", "illegal value of N");
        return -1;
    }
    if (NRHS < 0) {
        magma_error("MAGMA_ztrsmpl", "illegal value of NRHS");
        return -2;
    }
    if (LDA < max(1, N)) {
        magma_error("MAGMA_ztrsmpl", "illegal value of LDA");
        return -4;
    }
    if (LDB < max(1, N)) {
        magma_error("MAGMA_ztrsmpl", "illegal value of LDB");
        return -8;
    }
    /* Quick return */
    if (min(N, NRHS) == 0)
        return MAGMA_SUCCESS;

    /* Tune NB && IB depending on N && NRHS; Set NBNB */
    /* status = magma_tune(MAGMA_FUNC_ZGESV, N, N, NRHS); */
    /* if (status != MAGMA_SUCCESS) { */
    /*     magma_error("MAGMA_ztrsmpl", "magma_tune() failed"); */
    /*     return status; */
    /* } */

    /* Set Mt, NT && NTRHS */
    NB    = MAGMA_NB;
    IB    = MAGMA_IB;
    IBNB  = IB*NB;
    NT    = (N%NB==0) ? (N/NB) : (N/NB+1);

    magma_sequence_create(magma, &sequence);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   , magma_desc_mat_free(&(descA)) );
        magma_zooplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS, magma_desc_mat_free(&(descA)); magma_desc_mat_free(&(descB)));
    /* } else { */
    /*     magma_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N   ); */
    /*     magma_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS); */
    /* } */

    /* Call the tile interface */
    MAGMA_ztrsmpl_Tile_Async(&descA, L, IPIV, &descB, sequence, &request);

    /* if ( MAGMA_TRANSLATION == MAGMA_OUTOFPLACE ) { */
        magma_zooptile2lap( descB, B, NB, NB, LDB, NRHS );
        morse_barrier( magma );
        magma_desc_mat_free(&descA);
        magma_desc_mat_free(&descB);
    /* } else { */
    /*     magma_ziptile2lap( descA, A, NB, NB, LDA, N    ); */
    /*     magma_ziptile2lap( descB, B, NB, NB, LDB, NRHS ); */
    /*     morse_barrier( magma ); */
    /* } */

    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_ztrsmpl_Tile	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B
	)

MAGMA_ztrsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. All matrices are passed through descriptors. All dimensions are taken from the descriptors.

Parameters:

[in]	A	The tile factor L from the factorization, computed by MAGMA_zgetrf.
[in]	L	Auxiliary factorization data, related to the tile L factor, computed by MAGMA_zgetrf.
[in]	IPIV	The pivot indices from MAGMA_zgetrf (not equivalent to LAPACK).
[in,out]	B	On entry, the N-by-NRHS right hand side matrix B. On exit, if return value = 0, the N-by-NRHS solution matrix X.

Returns:

Return values:

MAGMA_SUCCESS

successful exit

See also:

MAGMA_ztrsmpl

MAGMA_ztrsmpl_Tile_Async

MAGMA_ctrsmpl_Tile

MAGMA_dtrsmpl_Tile

MAGMA_strsmpl_Tile

MAGMA_zgetrf_Tile

Definition at line 185 of file ztrsmpl.c.

References magma_context_self(), MAGMA_ERR_NOT_INITIALIZED, magma_fatal_error, MAGMA_REQUEST_INITIALIZER, magma_sequence_create(), magma_sequence_destroy(), MAGMA_ztrsmpl_Tile_Async(), morse_barrier(), morse_desc_getoncpu, and magma_sequence_s::status.

{
    magma_context_t *magma;
    magma_sequence_t *sequence = NULL;
    magma_request_t request = MAGMA_REQUEST_INITIALIZER;
    int status;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsmpl_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    magma_sequence_create(magma, &sequence);
    MAGMA_ztrsmpl_Tile_Async(A, L, IPIV, B, sequence, &request);
    morse_barrier( magma );
    morse_desc_getoncpu( A );
    morse_desc_getoncpu( L );
    morse_desc_getoncpu( B );
    status = sequence->status;
    magma_sequence_destroy(magma, sequence);
    return status;
}

Here is the call graph for this function:

int MAGMA_ztrsmpl_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	L,
		int *	IPIV,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

MAGMA_ztrsmpl_Tile - Performs the forward substitution step of solving a system of linear equations after the tile LU factorization of the matrix. Non-blocking equivalent of MAGMA_ztrsmpl_Tile(). Returns control to the user thread before worker threads finish the computation to allow for pipelined execution of diferent routines.

Parameters:

[in]	sequence	Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]	request	Identifies this function call (for exception handling purposes).

See also:

MAGMA_ztrsmpl

MAGMA_ztrsmpl_Tile

MAGMA_ctrsmpl_Tile_Async

MAGMA_dtrsmpl_Tile_Async

MAGMA_strsmpl_Tile_Async

MAGMA_zgetrf_Tile_Async

Definition at line 237 of file ztrsmpl.c.

References magma_desc_s::desc, magma_context_self(), magma_desc_check(), MAGMA_ERR_ILLEGAL_VALUE, MAGMA_ERR_NOT_INITIALIZED, MAGMA_ERR_SEQUENCE_FLUSHED, MAGMA_ERR_UNALLOCATED, magma_error, magma_fatal_error, magma_pztrsmpl(), magma_request_fail(), MAGMA_SUCCESS, magma_request_s::status, and magma_sequence_s::status.

{
    PLASMA_desc descA = A->desc;
    PLASMA_desc descB = B->desc;
    magma_context_t *magma;

    magma = magma_context_self();
    if (magma == NULL) {
        magma_fatal_error("MAGMA_ztrsmpl_Tile", "MAGMA not initialized");
        return MAGMA_ERR_NOT_INITIALIZED;
    }
    if (sequence == NULL) {
        magma_fatal_error("MAGMA_ztrsmpl_Tile", "NULL sequence");
        return MAGMA_ERR_UNALLOCATED;
    }
    if (request == NULL) {
        magma_fatal_error("MAGMA_ztrsmpl_Tile", "NULL request");
        return MAGMA_ERR_UNALLOCATED;
    }
    /* Check sequence status */
    if (sequence->status == MAGMA_SUCCESS)
        request->status = MAGMA_SUCCESS;
    else
        return magma_request_fail(sequence, request, MAGMA_ERR_SEQUENCE_FLUSHED);

    /* Check descriptors for correctness */
    if (magma_desc_check( A ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_ztrsmpl_Tile", "invalid first descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( L ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_ztrsmpl_Tile", "invalid second descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    if (magma_desc_check( B ) != MAGMA_SUCCESS) {
        magma_error("MAGMA_ztrsmpl_Tile", "invalid third descriptor");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Check input arguments */
    if (descA.nb != descA.mb || descB.nb != descB.mb) {
        magma_error("MAGMA_ztrsmpl_Tile", "only square tiles supported");
        return magma_request_fail(sequence, request, MAGMA_ERR_ILLEGAL_VALUE);
    }
    /* Quick return */
/*
    if (min(N, NRHS) == 0)
        return PLASMA_SUCCESS;
*/
    magma_pztrsmpl( A, B, L, IPIV, sequence, request);

    return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int MAGMA_ztrtri	(	PLASMA_enum	uplo,
		PLASMA_enum	diag,
		int	N,
		PLASMA_Complex64_t *	A,
		int	LDA
	)

int MAGMA_ztrtri_Tile	(	PLASMA_enum	uplo,
		PLASMA_enum	diag,
		magma_desc_t *	A
	)

int MAGMA_ztrtri_Tile_Async	(	PLASMA_enum	uplo,
		PLASMA_enum	diag,
		magma_desc_t *	A,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zunglq	(	int	M,
		int	N,
		int	K,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zunglq_Tile	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B
	)

int MAGMA_zunglq_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zungqr	(	int	M,
		int	N,
		int	K,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zungqr_Tile	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B
	)

int MAGMA_zungqr_Tile_Async	(	magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zunmlq	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		int	M,
		int	N,
		int	K,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zunmlq_Tile	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B
	)

int MAGMA_zunmlq_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)

int MAGMA_zunmqr	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		int	M,
		int	N,
		int	K,
		PLASMA_Complex64_t *	A,
		int	LDA,
		PLASMA_Complex64_t *	T,
		PLASMA_Complex64_t *	B,
		int	LDB
	)

int MAGMA_zunmqr_Tile	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B
	)

int MAGMA_zunmqr_Tile_Async	(	PLASMA_enum	side,
		PLASMA_enum	trans,
		magma_desc_t *	A,
		magma_desc_t *	T,
		magma_desc_t *	B,
		magma_sequence_t *	sequence,
		magma_request_t *	request
	)