PLASMA  2.4.5
PLASMA - Parallel Linear Algebra for Scalable Multi-core Architectures
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups
Macros | Functions
core_zblas.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

Functions

int CORE_zlarfx2 (int side, int N, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t *C1, int LDC1, PLASMA_Complex64_t *C2, int LDC2)
int CORE_zlarfx2c (int uplo, PLASMA_Complex64_t V, PLASMA_Complex64_t TAU, PLASMA_Complex64_t *C1, PLASMA_Complex64_t *C2, PLASMA_Complex64_t *C3)
int CORE_zlarfx2ce (int uplo, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *C1, PLASMA_Complex64_t *C2, PLASMA_Complex64_t *C3)
int CORE_zhbelr (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zhbrce (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zhblrx (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zgbelr (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zgbrce (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
int CORE_zgblrx (int uplo, int N, PLASMA_desc *A, PLASMA_Complex64_t *V, PLASMA_Complex64_t *TAU, int st, int ed, int eltsize)
void CORE_dzasum (int storev, int uplo, int M, int N, PLASMA_Complex64_t *A, int lda, double *work)
void CORE_zgeadd (int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_zbrdalg (PLASMA_enum uplo, int N, int NB, PLASMA_desc *pA, PLASMA_Complex64_t *C, PLASMA_Complex64_t *S, int i, int j, int m, int grsiz)
int CORE_zgelqt (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
void CORE_zgemm (int transA, int 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 CORE_zgeqrt (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zgessm (int M, int N, int K, int IB, int *IPIV, PLASMA_Complex64_t *L, int LDL, PLASMA_Complex64_t *A, int LDA)
int CORE_zgetrf (int M, int N, PLASMA_Complex64_t *A, int LDA, int *IPIV, int *INFO)
int CORE_zgetrf_incpiv (int M, int N, int IB, PLASMA_Complex64_t *A, int LDA, int *IPIV, int *INFO)
int CORE_zgetrf_reclap (const int M, const int N, PLASMA_Complex64_t *A, const int LDA, int *IPIV, int *info)
int CORE_zgetrf_rectil (const PLASMA_desc A, int *IPIV, int *info)
void CORE_zgetrip (int m, int n, PLASMA_Complex64_t *A, PLASMA_Complex64_t *work)
void CORE_zhegst (int itype, int uplo, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, int *INFO)
void CORE_zhemm (int side, int 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)
void CORE_zherk (int uplo, int trans, int N, int K, double alpha, PLASMA_Complex64_t *A, int LDA, double beta, PLASMA_Complex64_t *C, int LDC)
void CORE_zher2k (int uplo, int 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 CORE_zherfb (PLASMA_enum uplo, int N, int K, int IB, int NB, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)
void CORE_zlacpy (PLASMA_enum uplo, int M, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_zlange (int norm, int M, int N, PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlanhe (int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlansy (int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, double *work, double *normA)
void CORE_zlaset (PLASMA_enum uplo, int n1, int n2, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_Complex64_t *tileA, int ldtilea)
void CORE_zlaset2 (PLASMA_enum uplo, int n1, int n2, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *tileA, int ldtilea)
void CORE_zlaswp (int N, PLASMA_Complex64_t *A, int LDA, int I1, int I2, int *IPIV, int INC)
int CORE_zlaswp_ontile (PLASMA_desc descA, int i1, int i2, int *ipiv, int inc)
int CORE_zlaswpc_ontile (PLASMA_desc descA, int i1, int i2, int *ipiv, int inc)
void CORE_zlauum (int uplo, int N, PLASMA_Complex64_t *A, int LDA)
int CORE_zpamm (int op, int side, int storev, int M, int N, int K, int L, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *W, int LDW)
int CORE_zparfb (int side, int trans, int direct, int storev, int M1, int N1, int M2, int N2, int K, int L, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zpemv (int trans, int storev, int M, int N, int L, PLASMA_Complex64_t ALPHA, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *X, int INCX, PLASMA_Complex64_t BETA, PLASMA_Complex64_t *Y, int INCY, PLASMA_Complex64_t *WORK)
void CORE_zplghe (double bump, int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void CORE_zplgsy (PLASMA_Complex64_t bump, int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void CORE_zplrnt (int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void CORE_zpotrf (int uplo, int N, PLASMA_Complex64_t *A, int LDA, int *INFO)
void CORE_zshift (int s, int m, int n, int L, PLASMA_Complex64_t *A)
void CORE_zshiftw (int s, int cl, int m, int n, int L, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W)
int CORE_zssssm (int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *L1, int LDL1, PLASMA_Complex64_t *L2, int LDL2, int *IPIV)
void CORE_zsymm (int side, int 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)
void CORE_zsyrk (int uplo, int 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)
void CORE_zsyr2k (int uplo, int 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)
void CORE_zswpab (int i, int n1, int n2, PLASMA_Complex64_t *A, PLASMA_Complex64_t *work)
int CORE_zswptr_ontile (PLASMA_desc descA, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *Akk, int ldak)
void CORE_ztrdalg (PLASMA_enum uplo, int N, int NB, PLASMA_desc *pA, PLASMA_Complex64_t *C, PLASMA_Complex64_t *S, int i, int j, int m, int grsiz)
void CORE_ztrmm (int side, int uplo, int transA, int diag, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_ztrsm (int side, int uplo, int transA, int diag, int M, int N, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB)
void CORE_ztrtri (int uplo, int diag, int N, PLASMA_Complex64_t *A, int LDA, int *info)
int CORE_ztslqt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_ztsmlq (int side, int trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_ztsmlq_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmlq_hetra1 (int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmqr (int side, int trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_ztsmqr_corner (int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsmqr_hetra1 (int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *WORK, int ldwork)
int CORE_ztsqrt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_ztstrf (int M, int N, int IB, int NB, PLASMA_Complex64_t *U, int LDU, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *L, int LDL, int *IPIV, PLASMA_Complex64_t *WORK, int LDWORK, int *INFO)
int CORE_zttmqr (int side, int trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zttqrt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zttmlq (int side, int trans, int M1, int N1, int M2, int N2, int K, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zttlqt (int M, int N, int IB, PLASMA_Complex64_t *A1, int LDA1, PLASMA_Complex64_t *A2, int LDA2, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *TAU, PLASMA_Complex64_t *WORK)
int CORE_zunmlq (int side, int trans, int M, int N, int IB, int K, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)
int CORE_zunmqr (int side, int trans, int M, int N, int K, int IB, PLASMA_Complex64_t *V, int LDV, PLASMA_Complex64_t *T, int LDT, PLASMA_Complex64_t *C, int LDC, PLASMA_Complex64_t *WORK, int LDWORK)
void QUARK_CORE_dzasum (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_enum storev, PLASMA_enum uplo, int m, int n, PLASMA_Complex64_t *A, int lda, int szeA, double *work, int szeW)
void QUARK_CORE_dzasum_f1 (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_enum storev, PLASMA_enum uplo, int m, int n, PLASMA_Complex64_t *A, int lda, int szeA, double *work, int szeW, double *fake, int szeF)
void QUARK_CORE_zgeadd (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *B, int ldb)
void QUARK_CORE_zbrdalg (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int N, int NB, PLASMA_desc *A, PLASMA_Complex64_t *C, PLASMA_Complex64_t *S, int i, int j, int m, int grsiz, int BAND, int *PCOL, int *ACOL, int *MCOL)
void QUARK_CORE_zgelqt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zgemm (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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)
void QUARK_CORE_zgemm2 (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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)
void QUARK_CORE_zgemm_f2 (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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, PLASMA_Complex64_t *fake1, int szefake1, int flag1, PLASMA_Complex64_t *fake2, int szefake2, int flag2)
void QUARK_CORE_zgemm_p2 (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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)
void QUARK_CORE_zgemm_p2f1 (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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, PLASMA_Complex64_t *fake1, int szefake1, int flag1)
void QUARK_CORE_zgemm_p3 (Quark *quark, Quark_Task_Flags *task_flags, int transA, int transB, int m, int n, int k, int nb, 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)
void QUARK_CORE_zgeqrt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zgessm (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int k, int ib, int nb, int *IPIV, PLASMA_Complex64_t *L, int ldl, PLASMA_Complex64_t *A, int lda)
void QUARK_CORE_zgetrf (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int nb, PLASMA_Complex64_t *A, int lda, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request, PLASMA_bool check_info, int iinfo)
void QUARK_CORE_zgetrf_incpiv (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A, int lda, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request, PLASMA_bool check_info, int iinfo)
void QUARK_CORE_zgetrf_reclap (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int nb, PLASMA_Complex64_t *A, int lda, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request, PLASMA_bool check_info, int iinfo, int nbthread)
void QUARK_CORE_zgetrf_rectil (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_desc A, PLASMA_Complex64_t *Amn, int size, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request, PLASMA_bool check_info, int iinfo, int nbthread)
void QUARK_CORE_zgetrip (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, PLASMA_Complex64_t *A, int szeA)
void QUARK_CORE_zgetrip_f1 (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, PLASMA_Complex64_t *A, int szeA, PLASMA_Complex64_t *fake, int szeF, int paramF)
void QUARK_CORE_zgetrip_f2 (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, PLASMA_Complex64_t *A, int szeA, PLASMA_Complex64_t *fake1, int szeF1, int paramF1, PLASMA_Complex64_t *fake2, int szeF2, int paramF2)
void QUARK_CORE_zhemm (Quark *quark, Quark_Task_Flags *task_flags, int side, int uplo, int m, int n, int nb, 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)
void QUARK_CORE_zhegst (Quark *quark, Quark_Task_Flags *task_flags, int itype, int uplo, int N, PLASMA_Complex64_t *A, int LDA, PLASMA_Complex64_t *B, int LDB, PLASMA_sequence *sequence, PLASMA_request *request, int iinfo)
void QUARK_CORE_zherk (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int trans, int n, int k, int nb, double alpha, PLASMA_Complex64_t *A, int lda, double beta, PLASMA_Complex64_t *C, int ldc)
void QUARK_CORE_zher2k (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int trans, int n, int k, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *B, int LDB, double beta, PLASMA_Complex64_t *C, int ldc)
void QUARK_CORE_zherfb (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int n, int k, int ib, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *C, int ldc)
void QUARK_CORE_zlacpy (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_enum uplo, int m, int n, int mb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *B, int ldb)
void QUARK_CORE_zlange (Quark *quark, Quark_Task_Flags *task_flags, int norm, int M, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result)
void QUARK_CORE_zlange_f1 (Quark *quark, Quark_Task_Flags *task_flags, int norm, int M, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result, double *fake, int szeF)
void QUARK_CORE_zlanhe (Quark *quark, Quark_Task_Flags *task_flags, int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result)
void QUARK_CORE_zlanhe_f1 (Quark *quark, Quark_Task_Flags *task_flags, int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result, double *fake, int szeF)
void QUARK_CORE_zlansy (Quark *quark, Quark_Task_Flags *task_flags, int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result)
void QUARK_CORE_zlansy_f1 (Quark *quark, Quark_Task_Flags *task_flags, int norm, int uplo, int N, PLASMA_Complex64_t *A, int LDA, int szeA, int szeW, double *result, double *fake, int szeF)
void QUARK_CORE_zlaset (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_enum uplo, int n1, int n2, PLASMA_Complex64_t alpha, PLASMA_Complex64_t beta, PLASMA_Complex64_t *tileA, int ldtilea)
void QUARK_CORE_zlaset2 (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_enum uplo, int n1, int n2, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *tileA, int ldtilea)
void QUARK_CORE_zlaswp (Quark *quark, Quark_Task_Flags *task_flags, int n, PLASMA_Complex64_t *A, int lda, int i1, int i2, int *ipiv, int inc)
void QUARK_CORE_zlaswp_f2 (Quark *quark, Quark_Task_Flags *task_flags, int n, PLASMA_Complex64_t *A, int lda, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *fake1, int szefake1, int flag1, PLASMA_Complex64_t *fake2, int szefake2, int flag2)
void QUARK_CORE_zlaswp_ontile (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_desc descA, PLASMA_Complex64_t *A, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *fakepanel)
void QUARK_CORE_zlaswp_ontile_f2 (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_desc descA, PLASMA_Complex64_t *A, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *fake1, int szefake1, int flag1, PLASMA_Complex64_t *fake2, int szefake2, int flag2)
void QUARK_CORE_zlaswpc_ontile (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_desc descA, PLASMA_Complex64_t *A, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *fakepanel)
void QUARK_CORE_zlauum (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int n, int nb, PLASMA_Complex64_t *A, int lda)
void QUARK_CORE_zplghe (Quark *quark, Quark_Task_Flags *task_flags, double bump, int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void QUARK_CORE_zplgsy (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_Complex64_t bump, int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void QUARK_CORE_zplrnt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, PLASMA_Complex64_t *A, int lda, int bigM, int m0, int n0, unsigned long long int seed)
void QUARK_CORE_zpotrf (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int n, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_sequence *sequence, PLASMA_request *request, int iinfo)
void QUARK_CORE_zshift (Quark *quark, Quark_Task_Flags *task_flags, int s, int m, int n, int L, PLASMA_Complex64_t *A)
void QUARK_CORE_zshiftw (Quark *quark, Quark_Task_Flags *task_flags, int s, int cl, int m, int n, int L, PLASMA_Complex64_t *A, PLASMA_Complex64_t *W)
void QUARK_CORE_zssssm (Quark *quark, Quark_Task_Flags *task_flags, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *L1, int ldl1, PLASMA_Complex64_t *L2, int ldl2, int *IPIV)
void QUARK_CORE_zsymm (Quark *quark, Quark_Task_Flags *task_flags, int side, int uplo, int m, int n, int nb, 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)
void QUARK_CORE_zsyrk (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int trans, int n, int k, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t beta, PLASMA_Complex64_t *C, int ldc)
void QUARK_CORE_zsyr2k (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int trans, int n, int k, int nb, 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)
void QUARK_CORE_zswpab (Quark *quark, Quark_Task_Flags *task_flags, int i, int n1, int n2, PLASMA_Complex64_t *A, int szeA)
void QUARK_CORE_zswptr_ontile (Quark *quark, Quark_Task_Flags *task_flags, PLASMA_desc descA, PLASMA_Complex64_t *Aij, int i1, int i2, int *ipiv, int inc, PLASMA_Complex64_t *Akk, int ldak)
void QUARK_CORE_ztrdalg (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int N, int NB, PLASMA_desc *A, PLASMA_Complex64_t *C, PLASMA_Complex64_t *S, int i, int j, int m, int grsiz, int BAND, int *PCOL, int *ACOL, int *MCOL)
void QUARK_CORE_ztrmm (Quark *quark, Quark_Task_Flags *task_flags, int side, int uplo, int transA, int diag, int m, int n, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *B, int ldb)
void QUARK_CORE_ztrmm_p2 (Quark *quark, Quark_Task_Flags *task_flags, int side, int uplo, int transA, int diag, int m, int n, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t **B, int ldb)
void QUARK_CORE_ztrsm (Quark *quark, Quark_Task_Flags *task_flags, int side, int uplo, int transA, int diag, int m, int n, int nb, PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *B, int ldb)
void QUARK_CORE_ztrtri (Quark *quark, Quark_Task_Flags *task_flags, int uplo, int diag, int n, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_sequence *sequence, PLASMA_request *request, int iinfo)
void QUARK_CORE_ztslqt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmlq (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmlq_hetra1 (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmlq_corner (Quark *quark, Quark_Task_Flags *task_flags, int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmqr (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmqr_hetra1 (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsmqr_corner (Quark *quark, Quark_Task_Flags *task_flags, int m1, int n1, int m2, int n2, int m3, int n3, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *A3, int lda3, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztsqrt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_ztstrf (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *U, int ldu, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *L, int ldl, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request, PLASMA_bool check_info, int iinfo)
void QUARK_CORE_zttmqr (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zttqrt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zttmlq (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zttlqt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *T, int ldt)
void QUARK_CORE_zpamm (Quark *quark, Quark_Task_Flags *task_flags, int op, int side, int storev, int m, int n, int k, int l, PLASMA_Complex64_t *A1, int lda1, PLASMA_Complex64_t *A2, int lda2, PLASMA_Complex64_t *V, int ldv, PLASMA_Complex64_t *W, int ldw)
void QUARK_CORE_zunmlq (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m, int n, int ib, int nb, int k, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *C, int ldc)
void QUARK_CORE_zunmqr (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m, int n, int k, int ib, int nb, PLASMA_Complex64_t *A, int lda, PLASMA_Complex64_t *T, int ldt, PLASMA_Complex64_t *C, int ldc)
void CORE_dzasum_quark (Quark *quark)
void CORE_dzasum_f1_quark (Quark *quark)
void CORE_zgeadd_quark (Quark *quark)
void CORE_zbrdalg_quark (Quark *quark)
void CORE_zgelqt_quark (Quark *quark)
void CORE_zgemm_quark (Quark *quark)
void CORE_zgeqrt_quark (Quark *quark)
void CORE_zgessm_quark (Quark *quark)
void CORE_zgetrf_quark (Quark *quark)
void CORE_zgetrf_incpiv_quark (Quark *quark)
void CORE_zgetrf_reclap_quark (Quark *quark)
void CORE_zgetrf_rectil_quark (Quark *quark)
void CORE_zgetrip_quark (Quark *quark)
void CORE_zgetrip_f1_quark (Quark *quark)
void CORE_zgetrip_f2_quark (Quark *quark)
void CORE_zhemm_quark (Quark *quark)
void CORE_zherk_quark (Quark *quark)
void CORE_zher2k_quark (Quark *quark)
void CORE_zhegst_quark (Quark *quark)
void CORE_zherfb_quark (Quark *quark)
void CORE_zlacpy_quark (Quark *quark)
void CORE_zlange_quark (Quark *quark)
void CORE_zlange_f1_quark (Quark *quark)
void CORE_zlanhe_quark (Quark *quark)
void CORE_zlanhe_f1_quark (Quark *quark)
void CORE_zlansy_quark (Quark *quark)
void CORE_zlansy_f1_quark (Quark *quark)
void CORE_zlaset_quark (Quark *quark)
void CORE_zlaset2_quark (Quark *quark)
void CORE_zlauum_quark (Quark *quark)
void CORE_zpamm_quark (Quark *quark)
void CORE_zplghe_quark (Quark *quark)
void CORE_zplgsy_quark (Quark *quark)
void CORE_zplrnt_quark (Quark *quark)
void CORE_zpotrf_quark (Quark *quark)
void CORE_zshift_quark (Quark *quark)
void CORE_zshiftw_quark (Quark *quark)
void CORE_zssssm_quark (Quark *quark)
void CORE_zsymm_quark (Quark *quark)
void CORE_zsyrk_quark (Quark *quark)
void CORE_zsyr2k_quark (Quark *quark)
void CORE_zswpab_quark (Quark *quark)
void CORE_zswptr_ontile_quark (Quark *quark)
void CORE_ztrdalg_quark (Quark *quark)
void CORE_ztrmm_quark (Quark *quark)
void CORE_ztrsm_quark (Quark *quark)
void CORE_ztrtri_quark (Quark *quark)
void CORE_ztslqt_quark (Quark *quark)
void CORE_ztsmlq_quark (Quark *quark)
void CORE_ztsmlq_hetra1_quark (Quark *quark)
void CORE_ztsmlq_corner_quark (Quark *quark)
void CORE_ztsmqr_quark (Quark *quark)
void CORE_ztsmqr_hetra1_quark (Quark *quark)
void CORE_ztsmqr_corner_quark (Quark *quark)
void CORE_ztsqrt_quark (Quark *quark)
void CORE_ztstrf_quark (Quark *quark)
void CORE_zttmqr_quark (Quark *quark)
void CORE_zttqrt_quark (Quark *quark)
void CORE_zttmlq_quark (Quark *quark)
void CORE_zttlqt_quark (Quark *quark)
void CORE_zunmlq_quark (Quark *quark)
void CORE_zunmqr_quark (Quark *quark)
void CORE_zlaswp_quark (Quark *quark)
void CORE_zlaswp_f2_quark (Quark *quark)
void CORE_zlaswp_ontile_quark (Quark *quark)
void CORE_zlaswp_ontile_f2_quark (Quark *quark)
void CORE_zlaswpc_ontile_quark (Quark *quark)
void CORE_ztrmm_p2_quark (Quark *quark)
void CORE_zgemm_f2_quark (Quark *quark)
void CORE_zgemm_p2_quark (Quark *quark)
void CORE_zgemm_p2f1_quark (Quark *quark)
void CORE_zgemm_p3_quark (Quark *quark)

Detailed Description

PLASMA auxiliary routines PLASMA is a software package provided by Univ. of Tennessee, Univ. of California Berkeley and Univ. of Colorado Denver

Version:
2.4.5
Author:
Jakub Kurzak
Hatem Ltaief
Mathieu Faverge
Azzam Haidar
Date:
2010-11-15 normal z -> c d s

Definition in file core_zblas.h.

Macro Definition Documentation

#define COMPLEX

Definition at line 21 of file core_zblas.h.

Function Documentation

void CORE_dzasum ( int  storev,
int  uplo,
int  M,
int  N,
PLASMA_Complex64_t *  A,
int  lda,
double *  work 
)

Definition at line 28 of file core_dzasum.c.

References cabs(), PlasmaColumnwise, PlasmaLower, PlasmaUpper, PlasmaUpperLower, and sum().

{
PLASMA_Complex64_t *tmpA;
double *tmpW, sum, abs;
int i,j;
switch (uplo) {
case PlasmaUpper:
for (j = 0; j < N; j++) {
tmpA = A+(j*lda);
sum = 0.0;
for (i = 0; i < j; i++) {
abs = cabs(*tmpA);
sum += abs;
work[i] += abs;
tmpA++;
}
work[j] += sum + cabs(*tmpA);
}
break;
case PlasmaLower:
for (j = 0; j < N; j++) {
tmpA = A+(j*lda)+j;
sum = 0.0;
work[j] += cabs(*tmpA);
tmpA++;
for (i = j+1; i < M; i++) {
abs = cabs(*tmpA);
sum += abs;
work[i] += abs;
tmpA++;
}
work[j] += sum;
}
break;
case PlasmaUpperLower:
default:
if (storev == PlasmaColumnwise) {
for (j = 0; j < N; j++) {
/* work[j] += cblas_dzasum(M, &(A[j*lda]), 1); */
tmpA = A+(j*lda);
for (i = 0; i < M; i++) {
work[j] += cabs(*tmpA);
tmpA++;
}
}
}
else {
for (j = 0; j < N; j++) {
tmpA = A+(j*lda);
tmpW = work;
for (i = 0; i < M; i++) {
/* work[i] += cabs( A[j*lda+i] );*/
*tmpW += cabs( *tmpA );
tmpA++; tmpW++;
}
}
}
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_dzasum_f1_quark ( Quark *  quark)

Definition at line 162 of file core_dzasum.c.

References A, CORE_dzasum(), quark_unpack_args_8, storev, and uplo.

{
int storev;
int uplo;
int M;
int N;
PLASMA_Complex64_t *A;
int lda;
double *work;
double *fake;
quark_unpack_args_8(quark, storev, uplo, M, N, A, lda, work, fake);
CORE_dzasum(storev, uplo, M, N, A, lda, work);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_dzasum_quark ( Quark *  quark)
Declarations of QUARK wrappers (called by QUARK) - alphabetical order

Definition at line 119 of file core_dzasum.c.

References A, CORE_dzasum(), quark_unpack_args_7, storev, and uplo.

{
int storev;
int uplo;
int M;
int N;
PLASMA_Complex64_t *A;
int lda;
double *work;
quark_unpack_args_7(quark, storev, uplo, M, N, A, lda, work);
CORE_dzasum(storev, uplo, M, N, A, lda, work);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zbrdalg ( PLASMA_enum  uplo,
int  N,
int  NB,
PLASMA_desc *  pA,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  i,
int  j,
int  m,
int  grsiz 
)

CORE_zbrdalg is a part of the bidiagonal reduction algorithm (bulgechasing). It correspond to a local driver of the kernels that should be executed on a single core.

Parameters:
[in]uplo
  • PlasmaLower:
  • PlasmaUpper:
[in]NThe order of the matrix A. N >= 0.
[in]NBThe size of the Bandwidth of the matrix A, which correspond to the tile size. NB >= 0.
[in]pAA pointer to the descriptor of the matrix A.
[out]VPLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
[out]TAUPLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
[in]iInteger that refer to the current sweep. (outer loop).
[in]jInteger that refer to the sweep to chase.(inner loop).
[in]mInteger that refer to a sweep step, to ensure order dependencies.
[in]grsizInteger that refer to the size of a group. group mean the number of kernel that should be executed sequentially on the same core. group size is a trade-off between locality (cache reuse) and parallelism. a small group size increase parallelism while a large group size increase cache reuse.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 83 of file core_zbrdalg.c.

References A, CORE_zgbelr(), CORE_zgblrx(), CORE_zgbrce(), plasma_desc_t::dtyp, min, and plasma_element_size().

{
int k, shift=3;
int myid, colpt, stind, edind, blklastind, stepercol;
size_t eltsize;
PLASMA_desc A = *pA;
eltsize = plasma_element_size(A.dtyp);
k = shift / grsiz;
stepercol = (k*grsiz == shift) ? k : k+1;
for (k = 0; k < grsiz; k++){
myid = (i-j)*(stepercol*grsiz) +(m-1)*grsiz + k+1;
if(myid%2 ==0) {
colpt = (myid/2) * NB + 1 + j - 1;
stind = colpt - NB + 1;
edind = min(colpt, N);
blklastind = colpt;
} else {
colpt = ((myid+1)/2)*NB + 1 +j -1 ;
stind = colpt-NB+1;
edind = min(colpt,N);
if( (stind>=edind-1) && (edind==N) )
blklastind = N;
else
blklastind = 0;
}
if( myid == 1 )
CORE_zgbelr(uplo, N, &A, V, TAU, stind, edind, eltsize);
else if(myid%2 == 0)
CORE_zgbrce(uplo, N, &A, V, TAU, stind, edind, eltsize);
else /*if(myid%2 == 1)*/
CORE_zgblrx(uplo, N, &A, V, TAU, stind, edind, eltsize);
if(blklastind >= (N-1)) break;
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zbrdalg_quark ( Quark *  quark)

Definition at line 161 of file core_zbrdalg.c.

References CORE_zbrdalg(), quark_unpack_args_10, TAU, uplo, and V.

{
PLASMA_desc *pA;
PLASMA_Complex64_t *V;
PLASMA_Complex64_t *TAU;
int uplo;
int N, NB;
int i, j, m, grsiz;
quark_unpack_args_10(quark, uplo, N, NB, pA, V, TAU, i, j, m, grsiz);
CORE_zbrdalg(uplo, N, NB, pA, V, TAU, i, j, m, grsiz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgbelr ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 78 of file core_zgbelr.c.

References A, conj(), CORE_zlarfx2(), CORE_zlarfx2ce(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, TAU, and V.

{
int NB, J1, J2;
int len1, len2, t1ed, t2st;
int i;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(6, "Illegal value of st and ed (internal)");
return -6;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
if( uplo == PlasmaLower ){
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* generate Householder to annihilate a(i+k-1,i) within the band*/
*V(i) = *A(i, (st-1));
*A(i, (st-1)) = zzero;
LAPACKE_zlarfg_work( 2, A((i-1),(st-1)), V(i), 1, TAU(i));
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, (i-1)), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, (i-1)), A(i, t2st), ELTLDD(vA, i) );
CORE_zlarfx2ce(PlasmaLower, V(i), TAU(i), A(i-1,i-1), A(i,i-1), A(i,i));
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1,i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
}
} else {
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* generate Householder to annihilate a(i+k-1,i) within the band*/
*V(i) = *A((st-1), i);
*A((st-1), i) = zzero;
LAPACKE_zlarfg_work( 2, A((st-1), (i-1)), V(i), 1, TAU(i));
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1,i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
CORE_zlarfx2ce(PlasmaUpper, V(i), TAU(i), A((i-1),(i-1)), A((i-1), i), A(i,i));
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 1*/
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, (i-1)), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, (i-1)), A(i, t2st), ELTLDD(vA, i) );
}
} /* end of else for the upper case*/
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgblrx ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 78 of file core_zgblrx.c.

References A, conj(), CORE_zlarfx2(), CORE_zlarfx2ce(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, TAU, and V.

{
int NB, J1, J2;
int len1, len2, t1ed, t2st;
int i;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(6, "Illegal value of st and ed (internal)");
return -6;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
if( uplo == PlasmaLower ){
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, (i-1)), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, (i-1)), A(i, t2st), ELTLDD(vA, i) );
CORE_zlarfx2ce(PlasmaLower, V(i), TAU(i), A(i-1,i-1), A(i,i-1), A(i,i));
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1,i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
}
} else {
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1,i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
CORE_zlarfx2ce(PlasmaUpper, V(i), TAU(i), A(i-1,i-1), A(i-1, i), A(i,i));
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, (i-1)), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, (i-1)), A(i, t2st), ELTLDD(vA, i) );
}
} /* end of else for the upper case */
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgbrce ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 76 of file core_zgbrce.c.

References A, conj(), CORE_zlarfx2(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, TAU, and V.

{
int NB, J1, J2, J3, KDM2, len, pt;
int len1, len2, t1ed, t2st;
int i;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(6, "Illegal value of st and ed (internal)");
return -6;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
KDM2 = A->mb-2;
if( uplo == PlasmaLower ){
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply Householder from the right. and create newnnz outside the band if J3 < N */
J1 = ed+1;
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J1+1;
if(J3>J2)*A(J3,(i-1))=zzero;/* could be removed because A is supposed to be band.*/
t1ed = (J3/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J3-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1, i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st));
len = J3-J2;
if(len>0){
/* generate Householder to annihilate a(j+kd,j-1) within the band */
*V(J3) = *A(J3,(i-1));
*A(J3,(i-1)) = 0.0;
LAPACKE_zlarfg_work( 2, A(J2,(i-1)), V(J3), 1, TAU(J3));
}
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 2 */
for (i = ed; i >= st+1 ; i--){
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J2;
if(len>0){
pt = J2;
J1 = i;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(J3), conj(*TAU(J3)), A(pt, i ), ELTLDD(vA, pt), A((pt+1), i ), ELTLDD(vA, pt+1) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(J3), conj(*TAU(J3)), A(pt, t2st), ELTLDD(vA, pt), A((pt+1), t2st), ELTLDD(vA, pt+1) );
}
}
} else {
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply Householder from the right. and create newnnz outside the band if J3 < N */
J1 = ed+1;
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J1+1;
if(J3>J2)*A((i-1), J3)=zzero;
t1ed = (J3/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J3-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, i-1), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, i-1), A(i, t2st), ELTLDD(vA, i) );
/* if nonzero element a(j+kd,j-1) has been created outside the band (if index < N) then eliminate it. */
len = J3-J2;
if(len>0){
/* generate Householder to annihilate a(j+kd,j-1) within the band */
*V(J3) = *A(i-1, J3);
*A(i-1, J3) = 0.0;
LAPACKE_zlarfg_work( 2, A(i-1, J2), V(J3), 1, TAU(J3));
}
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 2 */
for (i = ed; i >= st+1 ; i--){
/* find if there was a nnz created. if yes apply right else nothing to be done. */
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J2;
if(len>0){
pt = J2;
J1 = i;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1 , conj(*V(J3)), conj(*TAU(J3)), A(i , pt), ELTLDD(vA, i), A(i, pt+1), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2 , conj(*V(J3)), conj(*TAU(J3)), A(t2st, pt), ELTLDD(vA, t2st), A(t2st, pt+1), ELTLDD(vA, t2st) );
}
}
} /* end of else for the upper case */
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgeadd ( int  M,
int  N,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB 
)

Definition at line 26 of file core_zgeadd.c.

References CBLAS_SADDR, and cblas_zaxpy().

{
int j;
if (M == LDA && M == LDB)
cblas_zaxpy(M*N, CBLAS_SADDR(alpha), A, 1, B, 1);
else {
for (j = 0; j < N; j++)
cblas_zaxpy(M, CBLAS_SADDR(alpha), &A[j*LDA], 1, &B[j*LDB], 1);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgeadd_quark ( Quark *  quark)

Definition at line 67 of file core_zgeadd.c.

References A, B, CBLAS_SADDR, cblas_zaxpy(), and quark_unpack_args_7.

{
int M;
int N;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t *A;
int LDA;
PLASMA_Complex64_t *B;
int LDB;
int j;
quark_unpack_args_7(quark, M, N, alpha, A, LDA, B, LDB);
if (M == LDA && M == LDB)
cblas_zaxpy(M*N, CBLAS_SADDR(alpha), A, 1, B, 1);
else {
for (j = 0; j < N; j++)
cblas_zaxpy(M, CBLAS_SADDR(alpha), &A[j*LDA], 1, &B[j*LDB], 1);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgelqt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_zgelqt - computes a LQ factorization of a complex M-by-N tile A: A = L * Q.

The tile Q is represented as a product of elementary reflectors

Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A(i,i+1:n), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A. M >= 0.
[in]NThe number of columns of the tile A. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]AOn entry, the M-by-N tile A. On exit, the elements on and below the diagonal of the array contain the M-by-min(M,N) lower trapezoidal tile L (L is lower triangular if M <= N); the elements above the diagonal, with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 85 of file core_zgelqt.c.

References coreblas_error, lapack_const, max, min, PLASMA_SUCCESS, PlasmaForward, PlasmaNoTrans, PlasmaRight, and PlasmaRowwise.

{
int i, k, sb;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if ((IB < 0) || ( (IB == 0) && ((M > 0) && (N > 0)) )) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(5, "Illegal value of LDA");
return -5;
}
if ((LDT < max(1,IB)) && (IB > 0)) {
coreblas_error(7, "Illegal value of LDT");
return -7;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
k = min(M, N);
for(i = 0; i < k; i += IB) {
sb = min(IB, k-i);
LAPACKE_zgelq2_work(LAPACK_COL_MAJOR, sb, N-i,
&A[LDA*i+i], LDA, &TAU[i], WORK);
LAPACKE_zlarft_work(LAPACK_COL_MAJOR,
lapack_const(PlasmaForward),
lapack_const(PlasmaRowwise),
N-i, sb,
&A[LDA*i+i], LDA, &TAU[i],
&T[LDT*i], LDT);
if (M > i+sb) {
LAPACKE_zlarfb_work(
LAPACK_COL_MAJOR,
lapack_const(PlasmaRight),
lapack_const(PlasmaNoTrans),
lapack_const(PlasmaForward),
lapack_const(PlasmaRowwise),
M-i-sb, N-i, sb,
&A[LDA*i+i], LDA,
&T[LDT*i], LDT,
&A[LDA*i+(i+sb)], LDA,
WORK, M-i-sb);
}
}
return PLASMA_SUCCESS;
}

Here is the caller graph for this function:

void CORE_zgelqt_quark ( Quark *  quark)

Definition at line 180 of file core_zgelqt.c.

References A, CORE_zgelqt(), quark_unpack_args_9, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
CORE_zgelqt(m, n, ib, A, lda, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm ( int  transA,
int  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 
)

Definition at line 28 of file core_zgemm.c.

References CBLAS_SADDR, cblas_zgemm(), and CblasColMajor.

{
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
M, N, K,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm_f2_quark ( Quark *  quark)

Definition at line 171 of file core_zgemm.c.

References A, B, C, CBLAS_SADDR, cblas_zgemm(), CblasColMajor, and quark_unpack_args_15.

{
int transA;
int 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;
void *fake1, *fake2;
quark_unpack_args_15(quark, transA, transB, M, N, K, alpha,
A, LDA, B, LDB, beta, C, LDC, fake1, fake2);
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
M, N, K,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm_p2_quark ( Quark *  quark)

Definition at line 234 of file core_zgemm.c.

References A, B, C, CBLAS_SADDR, cblas_zgemm(), CblasColMajor, and quark_unpack_args_13.

{
int transA;
int 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;
quark_unpack_args_13(quark, transA, transB, M, N, K, alpha,
A, LDA, B, LDB, beta, C, LDC);
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
M, N, K,
CBLAS_SADDR(alpha), A, LDA,
*B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm_p2f1_quark ( Quark *  quark)

Definition at line 360 of file core_zgemm.c.

References A, B, C, CBLAS_SADDR, cblas_zgemm(), CblasColMajor, and quark_unpack_args_14.

{
int transA;
int 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;
void *fake1;
quark_unpack_args_14(quark, transA, transB, M, N, K, alpha,
A, LDA, B, LDB, beta, C, LDC, fake1);
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
M, N, K,
CBLAS_SADDR(alpha), A, LDA,
*B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm_p3_quark ( Quark *  quark)

Definition at line 296 of file core_zgemm.c.

References A, B, C, CBLAS_SADDR, cblas_zgemm(), CblasColMajor, and quark_unpack_args_13.

{
int transA;
int 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;
quark_unpack_args_13(quark, transA, transB, M, N, K, alpha,
A, LDA, B, LDB, beta, C, LDC);
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
M, N, K,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), *C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgemm_quark ( Quark *  quark)

Definition at line 106 of file core_zgemm.c.

References A, B, C, CBLAS_SADDR, cblas_zgemm(), CblasColMajor, and quark_unpack_args_13.

{
int transA;
int 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;
quark_unpack_args_13(quark, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
cblas_zgemm(
CblasColMajor,
(CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB,
m, n, k,
CBLAS_SADDR(alpha), A, lda,
B, ldb,
CBLAS_SADDR(beta), C, ldc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgeqrt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_zgeqrt computes a QR factorization of a complex M-by-N tile A: A = Q * R.

The tile Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A(i+1:m,i), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A. M >= 0.
[in]NThe number of columns of the tile A. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]AOn entry, the M-by-N tile A. On exit, the elements on and above the diagonal of the array contain the min(M,N)-by-N upper trapezoidal tile R (R is upper triangular if M >= N); the elements below the diagonal, with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 86 of file core_zgeqrt.c.

References coreblas_error, lapack_const, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, and PlasmaLeft.

{
int i, k, sb;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if ((IB < 0) || ( (IB == 0) && ((M > 0) && (N > 0)) )) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(5, "Illegal value of LDA");
return -5;
}
if ((LDT < max(1,IB)) && (IB > 0)) {
coreblas_error(7, "Illegal value of LDT");
return -7;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
k = min(M, N);
for(i = 0; i < k; i += IB) {
sb = min(IB, k-i);
LAPACKE_zgeqr2_work(LAPACK_COL_MAJOR, M-i, sb,
&A[LDA*i+i], LDA, &TAU[i], WORK);
LAPACKE_zlarft_work(LAPACK_COL_MAJOR,
lapack_const(PlasmaForward),
lapack_const(PlasmaColumnwise),
M-i, sb,
&A[LDA*i+i], LDA, &TAU[i],
&T[LDT*i], LDT);
if (N > i+sb) {
LAPACKE_zlarfb_work(
LAPACK_COL_MAJOR,
lapack_const(PlasmaLeft),
lapack_const(PlasmaConjTrans),
lapack_const(PlasmaForward),
lapack_const(PlasmaColumnwise),
M-i, N-i-sb, sb,
&A[LDA*i+i], LDA,
&T[LDT*i], LDT,
&A[LDA*(i+sb)+i], LDA,
WORK, N-i-sb);
}
}
return PLASMA_SUCCESS;
}

Here is the caller graph for this function:

void CORE_zgeqrt_quark ( Quark *  quark)

Definition at line 181 of file core_zgeqrt.c.

References A, CORE_zgeqrt(), quark_unpack_args_9, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
CORE_zgeqrt(m, n, ib, A, lda, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgessm ( int  M,
int  N,
int  K,
int  IB,
int *  IPIV,
PLASMA_Complex64_t *  L,
int  LDL,
PLASMA_Complex64_t *  A,
int  LDA 
)

CORE_zgessm applies the factor L computed by CORE_zgetrf_incpiv to a complex M-by-N tile A.

Parameters:
[in]MThe number of rows of the tile A. M >= 0.
[in]NThe number of columns of the tile A. N >= 0.
[in]K
[in]IBThe inner-blocking size. IB >= 0.
[in]IPIVas returned by CORE_zgetrf_incpiv.
[in]LThe NB-by-NB lower triangular tile.
[in]LDLThe leading dimension of the array L. LDL >= max(1,NB).
[in,out]AOn entry, the M-by-N tile A. On exit, updated by the application of L.
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if INFO = -k, the k-th argument had an illegal value

Definition at line 68 of file core_zgessm.c.

References CBLAS_SADDR, cblas_zgemm(), cblas_ztrsm(), CblasColMajor, CblasLeft, CblasLower, CblasNoTrans, CblasUnit, coreblas_error, max, min, and PLASMA_SUCCESS.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t mzone = -1.0;
static int ione = 1;
int i, sb;
int tmp, tmp2;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (K < 0) {
coreblas_error(3, "Illegal value of K");
return -3;
}
if (IB < 0) {
coreblas_error(4, "Illegal value of IB");
return -4;
}
if ((LDL < max(1,M)) && (M > 0)) {
coreblas_error(7, "Illegal value of LDL");
return -7;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(9, "Illegal value of LDA");
return -9;
}
/* Quick return */
if ((M == 0) || (N == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
for(i = 0; i < K; i += IB) {
sb = min(IB, K-i);
/*
* Apply interchanges to columns I*IB+1:IB*( I+1 )+1.
*/
tmp = i+1;
tmp2 = i+sb;
LAPACKE_zlaswp_work(LAPACK_COL_MAJOR, N, A, LDA, tmp, tmp2, IPIV, ione);
/*
* Compute block row of U.
*/
cblas_ztrsm(
CblasColMajor, CblasLeft, CblasLower, CblasNoTrans, CblasUnit,
sb, N, CBLAS_SADDR(zone),
&L[LDL*i+i], LDL,
&A[i], LDA );
if (i+sb < M) {
/*
* Update trailing submatrix.
*/
cblas_zgemm(
CblasColMajor, CblasNoTrans, CblasNoTrans,
M-(i+sb), N, sb,
CBLAS_SADDR(mzone), &L[LDL*i+(i+sb)], LDL,
&A[i], LDA,
CBLAS_SADDR(zone), &A[i+sb], LDA );
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgessm_quark ( Quark *  quark)

Definition at line 172 of file core_zgessm.c.

References A, CORE_zgessm(), IPIV, L, and quark_unpack_args_9.

{
int m;
int n;
int k;
int ib;
int *IPIV;
PLASMA_Complex64_t *L;
int ldl;
PLASMA_Complex64_t *A;
int lda;
quark_unpack_args_9(quark, m, n, k, ib, IPIV, L, ldl, A, lda);
CORE_zgessm(m, n, k, ib, IPIV, L, ldl, A, lda);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgetrf ( int  M,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int *  IPIV,
int *  INFO 
)

Definition at line 22 of file core_zgetrf.c.

References PLASMA_SUCCESS.

{
*info = LAPACKE_zgetrf_work(LAPACK_COL_MAJOR, m, n, A, lda, IPIV );
return PLASMA_SUCCESS;
}
int CORE_zgetrf_incpiv ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A,
int  LDA,
int *  IPIV,
int *  INFO 
)

CORE_zgetrf_incpiv computes an LU factorization of a general M-by-N tile A using partial pivoting with row interchanges.

The factorization has the form

A = P * L * U

where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

This is the right-looking Level 2.5 BLAS version of the algorithm.

Parameters:
[in]MThe number of rows of the tile A. M >= 0.
[in]NThe number of columns of the tile A. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]AOn entry, the M-by-N tile to be factored. On exit, the factors L and U from the factorization A = P*L*U; the unit diagonal elements of L are not stored.
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).
[out]IPIVThe pivot indices; for 1 <= i <= min(M,N), row i of the tile was interchanged with row IPIV(i).
[out]INFOSee returned value.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if INFO = -k, the k-th argument had an illegal value
>0if INFO = k, U(k,k) 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.

Definition at line 83 of file core_zgetrf_incpiv.c.

References CORE_zgessm(), coreblas_error, max, min, and PLASMA_SUCCESS.

{
int i, j, k, sb;
int iinfo;
/* Check input arguments */
*INFO = 0;
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(5, "Illegal value of LDA");
return -5;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
k = min(M, N);
for(i =0 ; i < k; i += IB) {
sb = min(IB, k-i);
/*
* Factor diagonal and subdiagonal blocks and test for exact singularity.
*/
iinfo = LAPACKE_zgetf2_work(LAPACK_COL_MAJOR, M-i, sb, &A[LDA*i+i], LDA, &IPIV[i]);
/*
* Adjust INFO and the pivot indices.
*/
if((*INFO == 0) && (iinfo > 0))
*INFO = iinfo + i;
if (i+sb < N) {
CORE_zgessm(
M-i, N-(i+sb), sb, sb,
&IPIV[i],
&A[LDA*i+i], LDA,
&A[LDA*(i+sb)+i], LDA);
}
for(j = i; j < i+sb; j++) {
IPIV[j] = i + IPIV[j];
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgetrf_incpiv_quark ( Quark *  quark)

Definition at line 174 of file core_zgetrf_incpiv.c.

References A, CORE_zgetrf_incpiv(), IPIV, plasma_sequence_flush(), PLASMA_SUCCESS, and quark_unpack_args_10.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A;
int lda;
int *IPIV;
PLASMA_sequence *sequence;
PLASMA_request *request;
PLASMA_bool check_info;
int iinfo;
int info;
quark_unpack_args_10(quark, m, n, ib, A, lda, IPIV, sequence, request, check_info, iinfo);
CORE_zgetrf_incpiv(m, n, ib, A, lda, IPIV, &info);
if (info != PLASMA_SUCCESS && check_info)
plasma_sequence_flush(quark, sequence, request, iinfo+info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgetrf_quark ( Quark *  quark)

Definition at line 61 of file core_zgetrf.c.

References A, IPIV, plasma_sequence_flush(), PLASMA_SUCCESS, and quark_unpack_args_9.

{
int m;
int n;
PLASMA_Complex64_t *A;
int lda;
int *IPIV;
PLASMA_sequence *sequence;
PLASMA_request *request;
PLASMA_bool check_info;
int iinfo;
int info;
quark_unpack_args_9(quark, m, n, A, lda, IPIV, sequence, request, check_info, iinfo);
info = LAPACKE_zgetrf_work(LAPACK_COL_MAJOR, m, n, A, lda, IPIV );
if (info != PLASMA_SUCCESS && check_info)
plasma_sequence_flush(quark, sequence, request, iinfo+info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgetrf_reclap ( const int  M,
const int  N,
PLASMA_Complex64_t *  A,
const int  LDA,
int *  IPIV,
int *  info 
)

Definition at line 307 of file core_zgetrf_reclap.c.

References coreblas_error, max, min, and PLASMA_SUCCESS.

{
int thidx = info[1];
int thcnt = min( info[2], M / N );
int minMN = min(M, N);
if( M < 0 ) {
coreblas_error(1, "illegal value of M");
return -1;
}
if( N < 0 ) {
coreblas_error(2, "illegal value of N");
return -2;
}
if( LDA < max(1, M) ) {
coreblas_error(5, "illegal value of LDA");
return -5;
}
/*
* Quick return
*/
if ( (M == 0) || (N == 0) || (thidx >= thcnt) ){
return PLASMA_SUCCESS;
}
*info = 0;
CORE_zgetrf_reclap_rec( M, minMN, A, LDA, IPIV, info,
thidx, thcnt, 0 );
if ( N > minMN ) {
CORE_zgetrf_reclap_update(M, 0, minMN, N-minMN,
A, LDA, IPIV,
thidx, thcnt);
}
return info[0];
}

Here is the caller graph for this function:

void CORE_zgetrf_reclap_quark ( Quark *  quark)

Definition at line 381 of file core_zgetrf_reclap.c.

References A, CORE_zgetrf_reclap(), IPIV, plasma_sequence_flush(), PLASMA_SUCCESS, QUARK_Get_RankInTask(), and quark_unpack_args_10.

{
int M;
int N;
PLASMA_Complex64_t *A;
int LDA;
int *IPIV;
PLASMA_sequence *sequence;
PLASMA_request *request;
PLASMA_bool check_info;
int iinfo;
int info[3];
int maxthreads;
quark_unpack_args_10(quark, M, N, A, LDA, IPIV, sequence, request,
check_info, iinfo, maxthreads );
info[1] = QUARK_Get_RankInTask(quark);
info[2] = maxthreads;
CORE_zgetrf_reclap( M, N, A, LDA, IPIV, info );
if (info[1] == 0 && info[0] != PLASMA_SUCCESS && check_info)
plasma_sequence_flush(quark, sequence, request, iinfo + info[0] );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zgetrf_rectil ( const PLASMA_desc  A,
int *  IPIV,
int *  info 
)

Definition at line 653 of file core_zgetrf_rectil.c.

References coreblas_error, plasma_desc_t::m, min, plasma_desc_t::mt, plasma_desc_t::n, and plasma_desc_t::nt.

{
int ft, lt;
int thidx = info[1];
int thcnt = min( info[2], A.mt );
int minMN = min( A.m, A.n );
PLASMA_Complex64_t pivot;
if ( A.nt > 1 ) {
coreblas_error(1, "Illegal value of A.nt");
return -1;
}
if ( thidx >= thcnt )
return 0;
int q = A.mt / thcnt;
int r = A.mt % thcnt;
if (thidx < r) {
q++;
ft = thidx * q;
lt = ft + q;
} else {
ft = r * (q + 1) + (thidx - r) * q;
lt = ft + q;
lt = min( lt, A.mt );
}
info[0] = 0;
CORE_zgetrf_rectil_rec( A, IPIV, info, &pivot,
thidx, thcnt, 0, minMN, ft, lt);
if ( A.n > minMN ) {
CORE_zgetrf_rectil_update( A, IPIV,
0, minMN, A.n-minMN,
thidx, thcnt,
ft, lt);
}
return info[0];
}

Here is the caller graph for this function:

void CORE_zgetrf_rectil_quark ( Quark *  quark)

Definition at line 726 of file core_zgetrf_rectil.c.

References A, CORE_zgetrf_rectil(), IPIV, plasma_sequence_flush(), PLASMA_SUCCESS, QUARK_Get_RankInTask(), and quark_unpack_args_8.

{
PLASMA_desc A;
PLASMA_Complex64_t *Amn;
int *IPIV;
PLASMA_sequence *sequence;
PLASMA_request *request;
PLASMA_bool check_info;
int iinfo;
int info[3];
int maxthreads;
quark_unpack_args_8(quark, A, Amn, IPIV, sequence, request,
check_info, iinfo, maxthreads );
info[1] = QUARK_Get_RankInTask(quark);
info[2] = maxthreads;
CORE_zgetrf_rectil( A, IPIV, info );
if (info[1] == 0 && info[0] != PLASMA_SUCCESS && check_info)
plasma_sequence_flush(quark, sequence, request, iinfo + info[0] );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgetrip ( int  m,
int  n,
PLASMA_Complex64_t *  A,
PLASMA_Complex64_t *  W 
)

CORE_zgetrip transposes a m-by-n matrix in place using an extra workspace of size m-by-n. Note : For square tile, workspace is not used.

Parameters:
[in]mNumber of lines of tile A
[in]nNumber of columns of tile A
[in,out]ATile of size m-by-n On exit, A = trans(A)
[out]WWorkspace of size n-by-m if n != m, NULL otherwise.

Definition at line 54 of file core_zgetrip.c.

{
PLASMA_Complex64_t t;
int i, j;
if( m != n ) {
/* rectangular transposition (use workspace) */
for (i=0; i<m; i++) {
for (j=0; j<n; j++) {
W[j+i*n] = A[i+j*m];
}
}
memcpy(A, W, m*n*sizeof(PLASMA_Complex64_t));
}
else {
/* square transposition (swap pairwise) */
for (i=0; i<m; i++) {
for (j=i+1; j<n; j++) {
t = A[j+i*n];
A[j+i*n] = A[i+j*m];
A[i+j*m] = t;
}
}
}
}

Here is the caller graph for this function:

void CORE_zgetrip_f1_quark ( Quark *  quark)

Definition at line 138 of file core_zgetrip.c.

References A, CORE_zgetrip(), quark_unpack_args_5, and W.

{
int m;
int n;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *W;
PLASMA_Complex64_t *fake;
quark_unpack_args_5(quark, m, n, A, W, fake);
CORE_zgetrip(m, n, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgetrip_f2_quark ( Quark *  quark)

Definition at line 178 of file core_zgetrip.c.

References A, CORE_zgetrip(), quark_unpack_args_6, and W.

{
int m;
int n;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *W;
PLASMA_Complex64_t *fake1;
PLASMA_Complex64_t *fake2;
quark_unpack_args_6(quark, m, n, A, W, fake1, fake2);
CORE_zgetrip(m, n, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zgetrip_quark ( Quark *  quark)

Definition at line 101 of file core_zgetrip.c.

References A, CORE_zgetrip(), quark_unpack_args_4, and W.

{
int m;
int n;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *W;
quark_unpack_args_4(quark, m, n, A, W);
CORE_zgetrip(m, n, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zhbelr ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 78 of file core_zhbelr.c.

References A, conj(), CORE_zlarfx2(), CORE_zlarfx2c(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, TAU, and V.

{
int NB, J1, J2;
int len1, len2, t1ed, t2st;
int i;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(23, "Illegal value of st and ed (internal)");
return -23;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
if( uplo == PlasmaLower ) {
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* generate Householder to annihilate a(i+k-1,i) within the band */
*V(i) = *A(i, (st-1));
*A(i, (st-1)) = zzero;
LAPACKE_zlarfg_work( 2, A((i-1),(st-1)), V(i), 1, TAU(i));
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative */
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, i-1), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, i-1), A(i, t2st), ELTLDD(vA, i) );
CORE_zlarfx2c(PlasmaLower, *V(i), *TAU(i), A(i-1, i-1), A(i, i-1), A(i, i));
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative */
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, *V(i), *TAU(i), A(J1, i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, *V(i), *TAU(i), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
}
}else{
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* generate Householder to annihilate a(i+k-1,i) within the band*/
*V(i) = *A((st-1), i);
*A((st-1), i) = zzero;
LAPACKE_zlarfg_work( 2, A(st-1, i-1), V(i), 1, TAU(i));
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative */
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1, i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
CORE_zlarfx2c(PlasmaUpper, *V(i), *TAU(i), A(i-1, i-1), A(i-1, i), A(i,i));
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative */
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , conj(*V(i)), *TAU(i), A(i-1, J1 ), ELTLDD(vA, i-1), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , conj(*V(i)), *TAU(i), A(i-1, t2st), ELTLDD(vA, i-1), A(i, t2st), ELTLDD(vA, i) );
}
} /* end of else for the upper case */
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zhblrx ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 76 of file core_zhblrx.c.

References A, conj(), CORE_zlarfx2(), CORE_zlarfx2c(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, TAU, and V.

{
int NB, J1, J2;
int len1, len2, t1ed, t2st;
int i;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(6, "Illegal value of st and ed (internal)");
return -6;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
if( uplo == PlasmaLower ){
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(i), conj(*TAU(i)), A(i-1, J1 ), ELTLDD(vA, i-1), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(i), conj(*TAU(i)), A(i-1, t2st), ELTLDD(vA, i-1), A(i, t2st), ELTLDD(vA, i) );
CORE_zlarfx2c(PlasmaLower, *V(i), *TAU(i), A(i-1,i-1), A(i,i-1), A(i,i));
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, *V(i), *TAU(i), A(J1, i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, *V(i), *TAU(i), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
}
} else {
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/
J1 = st;
J2 = i-2;
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, conj(*V(i)), conj(*TAU(i)), A(J1, i-1), ELTLDD(vA, J1) , A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, conj(*V(i)), conj(*TAU(i)), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st) );
CORE_zlarfx2c(PlasmaUpper, *V(i), *TAU(i), A(i-1,i-1), A(i-1, i), A(i,i));
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 1 */
for (i = ed; i >= st+1 ; i--){
J1 = i+1;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1;
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , conj(*V(i)), *TAU(i), A(i-1, J1 ), ELTLDD(vA, i-1), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , conj(*V(i)), *TAU(i), A(i-1, t2st), ELTLDD(vA, i-1), A(i, t2st), ELTLDD(vA, i) );
}
} /* end of else for the upper case */
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zhbrce ( int  uplo,
int  N,
PLASMA_desc *  A,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  st,
int  ed,
int  eltsize 
)

Definition at line 76 of file core_zhbrce.c.

References A, conj(), CORE_zlarfx2(), coreblas_error, ELTLDD, max, plasma_desc_t::mb, min, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, TAU, and V.

{
int NB, J1, J2, J3, KDM2, len, pt;
int len1, len2, t1ed, t2st;
int i;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_desc vA=*A;
/* Check input arguments */
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (ed <= st) {
coreblas_error(6, "Illegal value of st and ed (internal)");
return -6;
}
/* Quick return */
if (N == 0)
return PLASMA_SUCCESS;
NB = A->mb;
KDM2 = A->mb-2;
if( uplo == PlasmaLower ) {
/* ========================
* LOWER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply Householder from the right. and create newnnz outside the band if J3 < N */
J1 = ed+1;
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J1+1;
if(J3>J2)*A(J3,(i-1))=zzero;/* could be removed because A is supposed to be band.*/
t1ed = (J3/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative*/
len2 = J3-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1, *V(i), *TAU(i), A(J1, i-1), ELTLDD(vA, J1), A(J1 , i), ELTLDD(vA, J1) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2, *V(i), *TAU(i), A(t2st,i-1), ELTLDD(vA, t2st), A(t2st, i), ELTLDD(vA, t2st));
/* if nonzero element a(j+kd,j-1) has been created outside the band (if index < N) then eliminate it.*/
len = J3-J2; // soit 1 soit 0
if(len>0){
/* generate Householder to annihilate a(j+kd,j-1) within the band */
*V(J3) = *A(J3,i-1);
*A(J3,i-1) = 0.0;
LAPACKE_zlarfg_work( 2, A(J2,i-1), V(J3), 1, TAU(J3));
}
}
/* APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 2 */
for (i = ed; i >= st+1 ; i--){
/* find if there was a nnz created. if yes apply left else nothing to be done.*/
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J2;
if(len>0){
pt = J2;
J1 = i;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative*/
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , *V(J3), conj(*TAU(J3)), A(pt, i ), ELTLDD(vA, pt), A((pt+1), i ), ELTLDD(vA, pt+1) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , *V(J3), conj(*TAU(J3)), A(pt, t2st), ELTLDD(vA, pt), A((pt+1), t2st), ELTLDD(vA, pt+1) );
}
}
} else {
/* ========================
* UPPER CASE
* ========================*/
for (i = ed; i >= st+1 ; i--){
/* apply Householder from the right. and create newnnz outside the band if J3 < N */
J1 = ed+1;
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J1+1;
if(J3>J2)*A((i-1), J3)=zzero;/* could be removed because A is supposed to be band.*/
t1ed = (J3/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative*/
len2 = J3-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaLeft, len1 , conj(*V(i)), *TAU(i), A(i-1, J1 ), ELTLDD(vA, (i-1)), A(i, J1 ), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaLeft, len2 , conj(*V(i)), *TAU(i), A(i-1, t2st), ELTLDD(vA, (i-1)), A(i, t2st), ELTLDD(vA, i) );
/* if nonzero element a(j+kd,j-1) has been created outside the band (if index < N) then eliminate it.*/
len = J3-J2; /* either 1 soit 0*/
if(len>0){
/* generate Householder to annihilate a(j+kd,j-1) within the band*/
*V(J3) = *A((i-1), J3);
*A((i-1), J3) = 0.0;
LAPACKE_zlarfg_work( 2, A((i-1), J2), V(J3), 1, TAU(J3));
}
}
/* APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 2*/
for (i = ed; i >= st+1 ; i--){
/* find if there was a nnz created. if yes apply right else nothing to be done.*/
J2 = min((i+1+KDM2), N);
J3 = min((J2+1), N);
len = J3-J2;
if(len>0){
pt = J2;
J1 = i;
J2 = min(ed,N);
t1ed = (J2/NB)*NB;
t2st = max(t1ed+1,J1);
len1 = t1ed-J1+1; /* can be negative*/
len2 = J2-t2st+1;
if(len1>0)CORE_zlarfx2(PlasmaRight, len1 , conj(*V(J3)), conj(*TAU(J3)), A(i , pt), ELTLDD(vA, i), A(i, pt+1), ELTLDD(vA, i) );
if(len2>0)CORE_zlarfx2(PlasmaRight, len2 , conj(*V(J3)), conj(*TAU(J3)), A(t2st, pt), ELTLDD(vA, t2st), A(t2st, pt+1), ELTLDD(vA, t2st) );
}
}
} /* end of else for the upper case */
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zhegst ( int  itype,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB,
int *  INFO 
)

Definition at line 27 of file core_zhegst.c.

References lapack_const.

{
*INFO = LAPACKE_zhegst_work(
LAPACK_COL_MAJOR,
itype,
lapack_const(uplo),
N, A, LDA, B, LDB );
}
void CORE_zhegst_quark ( Quark *  quark)

Definition at line 67 of file core_zhegst.c.

References A, B, itype, lapack_const, plasma_sequence_flush(), PLASMA_SUCCESS, quark_unpack_args_10, plasma_sequence_t::status, and uplo.

{
int itype;
PLASMA_enum uplo;
int n;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *B;
int ldb;
PLASMA_sequence *sequence;
PLASMA_request *request;
int iinfo;
int info;
quark_unpack_args_10(quark, itype, uplo, n, A, lda, B, ldb, sequence, request, iinfo);
info = LAPACKE_zhegst_work(
LAPACK_COL_MAJOR,
itype,
lapack_const(uplo),
n, A, lda, B, ldb);
if (sequence->status == PLASMA_SUCCESS && info != 0)
plasma_sequence_flush(quark, sequence, request, iinfo+info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zhemm ( int  side,
int  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 
)

Definition at line 31 of file core_zhemm.c.

References CBLAS_SADDR, cblas_zhemm(), and CblasColMajor.

{
cblas_zhemm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zhemm_quark ( Quark *  quark)

Definition at line 80 of file core_zhemm.c.

References A, B, C, CBLAS_SADDR, cblas_zhemm(), CblasColMajor, quark_unpack_args_12, side, and uplo.

{
int side;
int 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;
quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
cblas_zhemm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zher2k ( int  uplo,
int  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 
)

Definition at line 31 of file core_zher2k.c.

References CBLAS_SADDR, cblas_zher2k(), and CblasColMajor.

{
cblas_zher2k(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
N, K,
CBLAS_SADDR(alpha), A, LDA, B, LDB,
beta, C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zher2k_quark ( Quark *  quark)

Definition at line 79 of file core_zher2k.c.

References A, B, C, CORE_zher2k(), quark_unpack_args_12, trans, and uplo.

{
int uplo;
int 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;
quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
CORE_zher2k(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zherfb ( PLASMA_enum  uplo,
int  n,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  C,
int  ldc,
PLASMA_Complex64_t *  WORK,
int  ldwork 
)

CORE_zherfb overwrites the symmetric complex N-by-N tile C with

Q**T*C*Q

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_zgeqrt. Only PlasmaLower supported!

Parameters:
[in]uplo
  • PlasmaLower : the upper part of the symmetric matrix C is not referenced.
  • PlasmaUpper : the lower part of the symmetric matrix C is not referenced (not supported).
[in]nThe number of rows/columns of the tile C. N >= 0.
[in]kThe number of elementary reflectors whose product defines the matrix Q. K >= 0.
[in]ibThe inner-blocking size. IB >= 0.
[in]nbThe blocking size. NB >= 0.
[in]AThe i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgeqrt in the first k columns of its array argument A.
[in]ldaThe leading dimension of the array A. LDA >= max(1,N).
[out]TThe IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]ldtThe leading dimension of the array T. LDT >= IB.
[in,out]COn entry, the symmetric N-by-N tile C. On exit, C is overwritten by Q**T*C*Q.
[in]ldcThe leading dimension of the array C. LDC >= max(1,M).
[in,out]WORKOn exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
[in]ldworkThe dimension of the array WORK. LDWORK >= max(1,N);
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 110 of file core_zherfb.c.

References CORE_zunmlq(), CORE_zunmqr(), PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNoTrans, and PlasmaRight.

{
int i, j;
if (uplo == PlasmaLower) {
/* Rebuild the symmetric block: WORK <- C */
for (j = 0; j < n; j++)
for (i = j; i < n; i++){
*(WORK + i + j * ldwork) = *(C + i + j*ldc);
if (i > j){
*(WORK + j + i * ldwork) = *(WORK + i + j * ldwork);
#ifdef COMPLEX
LAPACKE_zlacgv_work(1, WORK + j + i * ldwork, ldwork);
#endif
}
}
/* Left */
CORE_zunmqr(PlasmaLeft, PlasmaConjTrans, n, n, k, ib,
A, lda, T, ldt, WORK, ldwork, WORK+nb*ldwork, ldwork);
/* Right */
CORE_zunmqr(PlasmaRight, PlasmaNoTrans, n, n, k, ib,
A, lda, T, ldt, WORK, ldwork, WORK+nb*ldwork, ldwork);
/*
* Copy back the final result to the lower part of C
*/
/* C = WORK */
for (j = 0; j < n; j++)
for (i = j; i < n; i++)
*(C + i + j*ldc) = *(WORK + i + j * ldwork);
}
else {
/* Rebuild the symmetric block: WORK <- C */
for (i = 0; i < n; i++)
for (j = i; j < n; j++){
*(WORK + i + j * ldwork) = *(C + i + j*ldc);
if (j > i){
*(WORK + j + i * ldwork) = *(WORK + i + j * ldwork);
#ifdef COMPLEX
LAPACKE_zlacgv_work(1, WORK + j + i * ldwork, ldwork);
#endif
}
}
/* Right */
CORE_zunmlq(PlasmaRight, PlasmaConjTrans, n, n, k, ib,
A, lda, T, ldt, WORK, ldwork, WORK+nb*ldwork, ldwork);
/* Left */
CORE_zunmlq(PlasmaLeft, PlasmaNoTrans, n, n, k, ib,
A, lda, T, ldt, WORK, ldwork, WORK+nb*ldwork, ldwork);
/*
* Copy back the final result to the upper part of C
*/
/* C = WORK */
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
*(C + i + j*ldc) = *(WORK + i + j * ldwork);
}
return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zherfb_quark ( Quark *  quark)

Definition at line 215 of file core_zherfb.c.

References A, C, CORE_zherfb(), quark_unpack_args_13, T, and uplo.

{
PLASMA_enum uplo;
int n;
int k;
int ib;
int nb;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *C;
int ldc;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_13(quark, uplo, n, k, ib, nb, A, lda, T, ldt, C, ldc, WORK, ldwork);
CORE_zherfb(uplo, n, k, ib, nb, A, lda, T, ldt, C, ldc, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 31 of file core_zherk.c.

References cblas_zherk(), and CblasColMajor.

{
cblas_zherk(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
N, K,
alpha, A, LDA,
beta, C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zherk_quark ( Quark *  quark)

Definition at line 75 of file core_zherk.c.

References A, C, cblas_zherk(), CblasColMajor, quark_unpack_args_10, trans, and uplo.

{
int uplo;
int trans;
int n;
int k;
double alpha;
PLASMA_Complex64_t *A;
int lda;
double beta;
PLASMA_Complex64_t *C;
int ldc;
quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
cblas_zherk(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
n, k,
alpha, A, lda,
beta, C, ldc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlacpy ( PLASMA_enum  uplo,
int  M,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB 
)

Definition at line 29 of file core_zlacpy.c.

References lapack_const.

{
LAPACKE_zlacpy_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N, A, LDA, B, LDB);
}

Here is the caller graph for this function:

void CORE_zlacpy_quark ( Quark *  quark)

Definition at line 66 of file core_zlacpy.c.

References A, B, lapack_const, quark_unpack_args_7, and uplo.

{
PLASMA_enum uplo;
int M;
int N;
PLASMA_Complex64_t *A;
int LDA;
PLASMA_Complex64_t *B;
int LDB;
quark_unpack_args_7(quark, uplo, M, N, A, LDA, B, LDB);
LAPACKE_zlacpy_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N, A, LDA, B, LDB);
}

Here is the caller graph for this function:

void CORE_zlange ( int  norm,
int  M,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
double *  work,
double *  normA 
)

Definition at line 29 of file core_zlange.c.

References lapack_const.

{
*normA = LAPACKE_zlange_work(
LAPACK_COL_MAJOR,
lapack_const(norm),
M, N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlange_f1_quark ( Quark *  quark)

Definition at line 114 of file core_zlange.c.

References A, lapack_const, norm, and quark_unpack_args_8.

{
double *normA;
int norm;
int M;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
double *fake;
quark_unpack_args_8(quark, norm, M, N, A, LDA, work, normA, fake);
*normA = LAPACKE_zlange_work(
LAPACK_COL_MAJOR,
lapack_const(norm),
M, N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlange_quark ( Quark *  quark)

Definition at line 67 of file core_zlange.c.

References A, lapack_const, norm, and quark_unpack_args_7.

{
double *normA;
int norm;
int M;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
quark_unpack_args_7(quark, norm, M, N, A, LDA, work, normA);
*normA = LAPACKE_zlange_work(
LAPACK_COL_MAJOR,
lapack_const(norm),
M, N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlanhe ( int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
double *  work,
double *  normA 
)

Definition at line 29 of file core_zlanhe.c.

References lapack_const.

{
*normA = LAPACKE_zlanhe_work(
LAPACK_COL_MAJOR,
lapack_const(norm), lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlanhe_f1_quark ( Quark *  quark)

Definition at line 113 of file core_zlanhe.c.

References A, lapack_const, norm, quark_unpack_args_8, and uplo.

{
double *normA;
int norm;
int uplo;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
double *fake;
quark_unpack_args_8(quark, norm, uplo, N, A, LDA, work, normA, fake);
*normA = LAPACKE_zlanhe_work(
LAPACK_COL_MAJOR,
lapack_const(norm), lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlanhe_quark ( Quark *  quark)

Definition at line 67 of file core_zlanhe.c.

References A, lapack_const, norm, quark_unpack_args_7, and uplo.

{
double *normA;
int norm;
int uplo;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
quark_unpack_args_7(quark, normA, norm, uplo, N, A, LDA, work);
*normA = LAPACKE_zlanhe_work(
LAPACK_COL_MAJOR,
lapack_const(norm), lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlansy ( int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
double *  work,
double *  normA 
)

Definition at line 29 of file core_zlansy.c.

References lapack_const.

{
*normA = LAPACKE_zlansy_work(
LAPACK_COL_MAJOR,
lapack_const(norm), lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlansy_f1_quark ( Quark *  quark)

Definition at line 114 of file core_zlansy.c.

References A, lapack_const, norm, quark_unpack_args_8, and uplo.

{
double *normA;
int norm;
int uplo;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
double *fake;
quark_unpack_args_8(quark, norm, uplo, N, A, LDA, work, normA, fake);
*normA = LAPACKE_zlansy_work(
LAPACK_COL_MAJOR,
lapack_const(norm),
lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

void CORE_zlansy_quark ( Quark *  quark)

Definition at line 67 of file core_zlansy.c.

References A, lapack_const, norm, quark_unpack_args_7, and uplo.

{
double *normA;
int norm;
int uplo;
int N;
PLASMA_Complex64_t *A;
int LDA;
double *work;
quark_unpack_args_7(quark, normA, norm, uplo, N, A, LDA, work);
*normA = LAPACKE_zlansy_work(
LAPACK_COL_MAJOR,
lapack_const(norm), lapack_const(uplo),
N, A, LDA, work);
}

Here is the caller graph for this function:

int CORE_zlarfx2 ( PLASMA_enum  side,
int  N,
PLASMA_Complex64_t  V,
PLASMA_Complex64_t  TAU,
PLASMA_Complex64_t *  C1,
int  LDC1,
PLASMA_Complex64_t *  C2,
int  LDC2 
)
Declarations of serial kernels - alphabetical order

Purpose

CORE_zlarfx2 applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right. H is represented in the form 

  H = I - tau * v * v'

where tau is a complex scalar and v is a complex vector.

If tau = 0, then H is taken to be the unit matrix

This version uses inline code if H has order < 11.

Arguments

Parameters:
[in]side
  • PlasmaLeft : form H * C
  • PlasmaRight: form C * H
[in]NThe number of columns of C1 and C2 if side = PlasmaLeft. The number of rows of C1 and C2 if side = PlasmaRight.
[in]VThe double complex V in the representation of H.
[in]TAUThe value tau in the representation of H.
[in,out]C1dimension (LDC1,N), if side = PlasmaLeft dimension (LDC1,1), if side = PlasmaRight On entry, the m by n matrix C1. On exit, C1 is overwritten by the matrix H * C1 if SIDE = PlasmaLeft, or C1 * H if SIDE = PlasmaRight.
[in]LDC1The leading dimension of the array C1. LDC1 >= max(1,N), if side == PlasmaRight. LDC1 >= 1, otherwise.
[in,out]C2dimension (LDC2,N), if side = PlasmaLeft dimension (LDC2,1), if side = PlasmaRight On entry, the m by n matrix C2. On exit, C2 is overwritten by the matrix H * C2 if SIDE = PlasmaLeft, or C2 * H if SIDE = PlasmaRight.
[in]LDC2The leading dimension of the array C2. LDC2 >= max(1,N), if side == PlasmaRight. LDC2 >= 1, otherwise.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 86 of file core_zlarfx_tbrd.c.

References conj(), PLASMA_SUCCESS, PlasmaLeft, T2, TAU, and V.

{
PLASMA_Complex64_t V2, T2, SUM;
int j;
if (TAU == (PLASMA_Complex64_t)0.0)
return PLASMA_SUCCESS;
/*
* Special code for 2 x 2 Householder where V1 = I
*/
if(side==PlasmaLeft){
V2 = conj(V);
T2 = TAU*conj(V2);
for (j = 0; j < N ; j++, C1+=LDC1 ) {
SUM = *C1 + V2 * (*C2);
*C1 = *C1 - SUM*TAU;
*C2 = *C2 - SUM*T2;
C2 += LDC2;
}
}
else {
V2 = V;
T2 = TAU*conj(V2);
for (j = 0; j < N ; j++, C1++){
SUM = *C1 + V2 * (*C2);
*C1 = *C1 - SUM*TAU;
*C2 = *C2 - SUM*T2;
C2++;
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zlarfx2c ( PLASMA_enum  uplo,
PLASMA_Complex64_t  V,
PLASMA_Complex64_t  TAU,
PLASMA_Complex64_t *  C1,
PLASMA_Complex64_t *  C2,
PLASMA_Complex64_t *  C3 
)

Purpose

CORE_zlarfx2c applies a complex elementary reflector H to a diagonal corner C=[C1, C2, C3], from both the left and the right side. C = H * C * H. It is used in the case of Hermetian. If PlasmaLower, a left apply is followed by a right apply. If PlasmaUpper, a right apply is followed by a left apply. H is represented in the form

This routine is a special code for a corner C diagonal block C1 C2 C3

H = I - tau * v * v'

where tau is a complex scalar and v is a complex vector.

If tau = 0, then H is taken to be the unit matrix

This version uses inline code if H has order < 11.

Arguments

Parameters:
[in]uplo= PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in]VThe double complex V in the representation of H.
[in]TAUThe value tau in the representation of H.
[in,out]C1On entry, the element C1. On exit, C1 is overwritten by the result H * C * H.
[in,out]C2On entry, the element C2. On exit, C2 is overwritten by the result H * C * H.
[in,out]C3On entry, the element C3. On exit, C3 is overwritten by the result H * C * H.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 185 of file core_zlarfx_tbrd.c.

References conj(), PLASMA_SUCCESS, PlasmaLower, T2, TAU, and V.

{
PLASMA_Complex64_t T2, SUM, TEMP;
/* Quick return */
if (TAU == (PLASMA_Complex64_t)0.0)
return PLASMA_SUCCESS;
/*
* Special code for a diagonal block C1
* C2 C3
*/
if(uplo==PlasmaLower) {
/*
* Do the corner Left then Right (used for the lower case
* tridiag) L and R for the 2x2 corner
* C(N-1, N-1) C(N-1,N) C1 TEMP
* C(N , N-1) C(N ,N) C2 C3
* For Left : use conj(TAU) and V.
* For Right: nothing, keep TAU and V.
* Left 1 ==> C1
* C2
*/
TEMP = conj(*C2); /* copy C2 here before modifying it. */
T2 = conj(TAU) * V;
SUM = *C1 + conj(V) * (*C2);
*C1 = *C1 - SUM * conj(TAU);
*C2 = *C2 - SUM * T2;
/* Left 2 ==> TEMP */
/* C3 */
SUM = TEMP + conj(V) * (*C3);
TEMP = TEMP - SUM * conj(TAU);
*C3 = *C3 - SUM * T2;
/* Right 1 ==> C1 TEMP. NB: no need to compute corner (2,2)=TEMP */
T2 = TAU * conj(V);
SUM = *C1 + V*TEMP;
*C1 = *C1 - SUM*TAU;
/* Right 2 ==> C2 C3 */
SUM = *C2 + V*(*C3);
*C2 = *C2 - SUM*TAU;
*C3 = *C3 - SUM*T2;
}
else {
/*
* Do the corner Right then Left (used for the upper case tridiag)
* C(N-1, N-1) C(N-1,N) C1 C2
* C(N , N-1) C(N ,N) TEMP C3
* For Left : use TAU and conj(V).
* For Right: use conj(TAU) and conj(V).
* Right 1 ==> C1 C2
*/
V = conj(V);
TEMP = conj(*C2); /* copy C2 here before modifying it. */
T2 = conj(TAU) * conj(V);
SUM = *C1 + V * (*C2);
*C1 = *C1 - SUM * conj(TAU);
*C2 = *C2 - SUM * T2;
/* Right 2 ==> TEMP C3 */
SUM = TEMP + V * (*C3);
TEMP = TEMP - SUM * conj(TAU);
*C3 = *C3 - SUM * T2;
/* Left 1 ==> C1 */
/* TEMP. NB: no need to compute corner (2,1)=TEMP */
T2 = TAU * V;
SUM = *C1 + conj(V) * TEMP;
*C1 = *C1 - SUM * TAU;
/* Left 2 ==> C2 */
/* C3 */
SUM = *C2 + conj(V) * (*C3);
*C2 = *C2 - SUM * TAU;
*C3 = *C3 - SUM * T2;
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zlarfx2ce ( PLASMA_enum  uplo,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  C1,
PLASMA_Complex64_t *  C2,
PLASMA_Complex64_t *  C3 
)

Purpose

CORE_zlarfx2c applies a complex elementary reflector H to a diagonal corner C=[C1, C2, C3], from both the left and the right side. C = H * C * H. It is used in the case of general matrices, where it create a nnz at the NEW_NNZ position, then it eliminate it and update the reflector V and TAU. If PlasmaLower, a left apply is followed by a right apply. If PlasmaUpper, a right apply is followed by a left apply. H is represented in the form

This routine is a special code for a corner C diagonal block C1 NEW_NNZ C2 C3

H = I - tau * v * v'

where tau is a complex scalar and v is a complex vector.

If tau = 0, then H is taken to be the unit matrix

This version uses inline code if H has order < 11.

Arguments

Parameters:
[in]uplo= PlasmaUpper: Upper triangle of A is stored; = PlasmaLower: Lower triangle of A is stored.
[in,out]VOn entry, the double complex V in the representation of H. On exit, the double complex V in the representation of H, updated by the elimination of the NEW_NNZ created by the left apply in case of PlasmaLower or the right apply in case of PlasmaUpper.
[in]TAUOn entry, the value tau in the representation of H. On exit, the value tau in the representation of H, updated by the elimination of the NEW_NNZ created by the left apply in case of PlasmaLower or the right apply in case of PlasmaUpper.
[in,out]C1On entry, the element C1. On exit, C1 is overwritten by the result H * C * H.
[in,out]C2On entry, the element C2. On exit, C2 is overwritten by the result H * C * H.
[in,out]C3On entry, the element C3. On exit, C3 is overwritten by the result H * C * H.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 335 of file core_zlarfx_tbrd.c.

References conj(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, T2, and V.

{
PLASMA_Complex64_t T2, SUM, TEMP, VIN, TAUIN;
/* Quick return */
if (*TAU == (PLASMA_Complex64_t)0.0)
return PLASMA_SUCCESS;
/*
* Special code for a diagonal block C1
* C2 C3
*/
if(uplo==PlasmaLower){
/*
* Do the corner for the lower case BIDIAG ==> Left then will
* create a new nnz. eliminate it and modify V TAU and then
* Right L and R for the 2x2 corner
* C(N-1, N-1) C(N-1,N) C1 TEMP
* C(N , N-1) C(N ,N) C2 C3
*/
VIN = *V;
TAUIN = conj(*TAU);
/* Left 1 ==> C1 */
/* C2 */
VIN = conj(VIN);
T2 = TAUIN * conj(VIN);
SUM = *C1 + VIN*(*C2);
*C1 = *C1 - SUM*TAUIN;
*C2 = *C2 - SUM*T2;
/* new nnz at TEMP and update C3 */
SUM = VIN * (*C3);
TEMP = - SUM * TAUIN;
*C3 = *C3 - SUM * T2;
/* generate Householder to annihilate the nonzero created at TEMP */
*V = TEMP;
LAPACKE_zlarfg_work( 2, C1, V, 1, TAU);
VIN = conj(*V);
TAUIN = conj(*TAU);
/* Right 1 ==> C2 C3 */
/* VIN = VIN */
T2 = TAUIN * conj(VIN);
SUM = *C2 + VIN*(*C3);
*C2 = *C2 - SUM*TAUIN;
*C3 = *C3 - SUM*T2;
}else if(uplo==PlasmaUpper){
/*
* Do the corner for the upper case BIDIAG ==> Right then will
* create a new nnz. eliminate it and modify V TAU and then
* Left
* C(N-1, N-1) C(N-1,N) C1 C2
* C(N , N-1) C(N ,N) TEMP C3
* For Left : use conj(TAU) and V.
* For Right: use conj(TAU) and conj(V) as input.
*/
VIN = conj(*V);
TAUIN = conj(*TAU);
/* Right 1 ==> C1 C2 */
/* VIN = VIN */
T2 = TAUIN*conj(VIN);
SUM = *C1 + VIN*(*C2);
*C1 = *C1 - SUM*TAUIN;
*C2 = *C2 - SUM*T2;
/* new nnz at TEMP and update C3 */
SUM = VIN * (*C3);
TEMP = - SUM * TAUIN;
*C3 = *C3 - SUM * T2;
/* generate Householder to annihilate the nonzero created at TEMP */
*V = TEMP;
LAPACKE_zlarfg_work( 2, C1, V, 1, TAU);
VIN = *V;
TAUIN = conj(*TAU);
/* apply from the Left using the NEW V TAU to the remaining 2 elements [C2 C3] */
/* Left 2 ==> C2 */
/* C3 */
VIN = conj(VIN);
T2 = TAUIN*conj(VIN);
SUM = *C2 + VIN*(*C3);
*C2 = *C2 - SUM*TAUIN;
*C3 = *C3 - SUM*T2;
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaset ( PLASMA_enum  uplo,
int  M,
int  N,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t  beta,
PLASMA_Complex64_t *  A,
int  LDA 
)

CORE_zlaset - Sets the elements of the matrix A on the diagonal to beta and on the off-diagonals to alpha

Parameters:
[in]uploSpecifies which elements of the matrix are to be set = PlasmaUpper: Upper part of A is set; = PlasmaLower: Lower part of A is set; = PlasmaUpperLower: ALL elements of A are set.
[in]MThe number of rows of the matrix A. M >= 0.
[in]NThe number of columns of the matrix A. N >= 0.
[in]alphaThe constant to which the off-diagonal elements are to be set.
[in]betaThe constant to which the diagonal elements are to be set.
[in,out]AOn entry, the M-by-N tile A. On exit, A has been set accordingly.
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).

Definition at line 58 of file core_zlaset.c.

References lapack_const.

{
LAPACKE_zlaset_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N, alpha, beta, A, LDA);
}

Here is the caller graph for this function:

void CORE_zlaset2 ( PLASMA_enum  uplo,
int  M,
int  N,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  LDA 
)

CORE_zlaset2 - Sets the elements of the matrix A to alpha. Not LAPACK compliant! Read below.

Parameters:
[in]uploSpecifies which elements of the matrix are to be set = PlasmaUpper: STRICT Upper part of A is set to alpha; = PlasmaLower: STRICT Lower part of A is set to alpha; = PlasmaUpperLower: ALL elements of A are set to alpha. Not LAPACK Compliant.
[in]MThe number of rows of the matrix A. M >= 0.
[in]NThe number of columns of the matrix A. N >= 0.
[in]alphaThe constant to which the elements are to be set.
[in,out]AOn entry, the M-by-N tile A. On exit, A has been set to alpha accordingly.
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).

Definition at line 56 of file core_zlaset2.c.

References lapack_const, PlasmaLower, and PlasmaUpper.

{
if (uplo == PlasmaUpper) {
LAPACKE_zlaset_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N-1, alpha, alpha, A+LDA, LDA);
}
else if (uplo == PlasmaLower) {
LAPACKE_zlaset_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M-1, N, alpha, alpha, A+1, LDA);
}
else {
LAPACKE_zlaset_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N, alpha, alpha, A, LDA);
}
}

Here is the caller graph for this function:

void CORE_zlaset2_quark ( Quark *  quark)

Definition at line 103 of file core_zlaset2.c.

References A, CORE_zlaset2(), quark_unpack_args_6, and uplo.

{
int uplo;
int M;
int N;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t *A;
int LDA;
quark_unpack_args_6(quark, uplo, M, N, alpha, A, LDA);
CORE_zlaset2(uplo, M, N, alpha, A, LDA);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaset_quark ( Quark *  quark)

Definition at line 95 of file core_zlaset.c.

References A, lapack_const, quark_unpack_args_7, and uplo.

{
int uplo;
int M;
int N;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t beta;
PLASMA_Complex64_t *A;
int LDA;
quark_unpack_args_7(quark, uplo, M, N, alpha, beta, A, LDA);
LAPACKE_zlaset_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
M, N, alpha, beta, A, LDA);
}

Here is the caller graph for this function:

void CORE_zlaswp ( int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  I1,
int  I2,
int *  IPIV,
int  INC 
)

Definition at line 29 of file core_zlaswp.c.

{
LAPACKE_zlaswp_work( LAPACK_COL_MAJOR, N, A, LDA, I1, I2, IPIV, INC );
}
void CORE_zlaswp_f2_quark ( Quark *  quark)

Definition at line 102 of file core_zlaswp.c.

References A, and quark_unpack_args_9.

{
int n, lda, i1, i2, inc;
int *ipiv;
PLASMA_Complex64_t *A;
void *fake1, *fake2;
quark_unpack_args_9(quark, n, A, lda, i1, i2, ipiv, inc, fake1, fake2);
LAPACKE_zlaswp_work(LAPACK_COL_MAJOR, n, A, lda, i1, i2, ipiv, inc );
}

Here is the caller graph for this function:

int CORE_zlaswp_ontile ( PLASMA_desc  descA,
int  i1,
int  i2,
int *  ipiv,
int  inc 
)

CORE_zlaswp_ontile apply the zlaswp function on a matrix stored in tile layout

Parameters:
[in,out]AThe descriptor of the matrix A to permute.
[in]i1The first element of IPIV for which a row interchange will be done.
[in]i2The last element of IPIV for which a row interchange will be done.
[in]ipivThe pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
[in]incThe increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

Definition at line 147 of file core_zlaswp.c.

References A, BLKLDD, cblas_zswap(), coreblas_error, plasma_desc_t::i, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::mt, plasma_desc_t::n, plasma_desc_t::nt, and PLASMA_SUCCESS.

{
int i, j, ip, it;
PLASMA_Complex64_t *A1;
int lda1, lda2;
/* Change i1 to C notation */
i1--;
if ( descA.nt > 1 ) {
coreblas_error(1, "Illegal value of descA.nt");
return -1;
}
if ( i1 < 0 ) {
coreblas_error(2, "Illegal value of i1");
return -2;
}
if ( (i2 < i1) || (i2 > descA.m) ) {
coreblas_error(3, "Illegal value of i2");
return -3;
}
if ( ! ( (i2 - i1 - i1%descA.mb -1) < descA.mb ) ) {
coreblas_error(2, "Illegal value of i1,i2. They have to be part of the same block.");
return -3;
}
it = i1 / descA.mb;
if (inc > 0) {
A1 = A(it, 0);
lda1 = BLKLDD(descA, 0);
for (j = i1; j < i2; ++j, ipiv+=inc) {
ip = (*ipiv) - descA.i - 1;
if ( ip != j )
{
it = ip / descA.mb;
i = ip % descA.mb;
lda2 = BLKLDD(descA, it);
cblas_zswap(descA.n, A1 + j, lda1,
A(it, 0) + i, lda2 );
}
}
}
else
{
A1 = A(it, 0);
lda1 = BLKLDD(descA, descA.mt-1);
i1--;
ipiv = &ipiv[(1-i2)*inc];
for (j = i2-1; j > i1; --j, ipiv+=inc) {
ip = (*ipiv) - descA.i - 1;
if ( ip != j )
{
it = ip / descA.mb;
i = ip % descA.mb;
lda2 = BLKLDD(descA, it);
cblas_zswap(descA.n, A1 + j, lda1,
A(it, 0) + i, lda2 );
}
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaswp_ontile_f2_quark ( Quark *  quark)

Definition at line 279 of file core_zlaswp.c.

References A, CORE_zlaswp_ontile(), and quark_unpack_args_8.

{
int i1, i2, inc;
int *ipiv;
PLASMA_Complex64_t *A;
PLASMA_desc descA;
void *fake1, *fake2;
quark_unpack_args_8(quark, descA, A, i1, i2, ipiv, inc, fake1, fake2);
CORE_zlaswp_ontile(descA, i1, i2, ipiv, inc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaswp_ontile_quark ( Quark *  quark)

Definition at line 238 of file core_zlaswp.c.

References A, CORE_zlaswp_ontile(), and quark_unpack_args_7.

{
int i1, i2, inc;
int *ipiv;
PLASMA_Complex64_t *A, *fake;
PLASMA_desc descA;
quark_unpack_args_7(quark, descA, A, i1, i2, ipiv, inc, fake);
CORE_zlaswp_ontile(descA, i1, i2, ipiv, inc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaswp_quark ( Quark *  quark)

Definition at line 61 of file core_zlaswp.c.

References A, and quark_unpack_args_7.

{
int n, lda, i1, i2, inc;
int *ipiv;
PLASMA_Complex64_t *A;
quark_unpack_args_7(quark, n, A, lda, i1, i2, ipiv, inc);
LAPACKE_zlaswp_work(LAPACK_COL_MAJOR, n, A, lda, i1, i2, ipiv, inc );
}

Here is the caller graph for this function:

int CORE_zlaswpc_ontile ( PLASMA_desc  descA,
int  i1,
int  i2,
int *  ipiv,
int  inc 
)

CORE_zlaswpc_ontile apply the zlaswp function on a matrix stored in tile layout

Parameters:
[in,out]AThe descriptor of the matrix A to permute.
[in]i1The first element of IPIV for which a column interchange will be done.
[in]i2The last element of IPIV for which a column interchange will be done.
[in]ipivThe pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
[in]incThe increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

Definition at line 430 of file core_zlaswp.c.

References A, BLKLDD, cblas_zswap(), coreblas_error, plasma_desc_t::j, plasma_desc_t::m, plasma_desc_t::mt, plasma_desc_t::n, plasma_desc_t::nb, and PLASMA_SUCCESS.

{
int i, j, ip, it;
PLASMA_Complex64_t *A1;
int lda;
if ( descA.mt > 1 ) {
coreblas_error(1, "Illegal value of descA.mt");
return -1;
}
if ( i1 < 1 ) {
coreblas_error(2, "Illegal value of i1");
return -2;
}
if ( (i2 < i1) || (i2 > descA.n) ) {
coreblas_error(3, "Illegal value of i2");
return -3;
}
if ( ! ( (i2 - i1 - i1%descA.nb -1) < descA.nb ) ) {
coreblas_error(2, "Illegal value of i1,i2. They have to be part of the same block.");
return -3;
}
lda = BLKLDD(descA, 0);
it = i1 / descA.nb;
if (inc > 0) {
A1 = A(0, it);
for (j = i1-1; j < i2; ++j, ipiv+=inc) {
ip = (*ipiv) - descA.j - 1;
if ( ip != j )
{
it = ip / descA.nb;
i = ip % descA.nb;
cblas_zswap(descA.m, A1 + j*lda, 1,
A(0, it) + i*lda, 1 );
}
}
}
else
{
A1 = A(0, it);
i1 -= 2;
ipiv = &ipiv[(1-i2)*inc];
for (j = i2-1; j > i1; --j, ipiv+=inc) {
ip = (*ipiv) - descA.j - 1;
if ( ip != j )
{
it = ip / descA.nb;
i = ip % descA.nb;
cblas_zswap(descA.m, A1 + j*lda, 1,
A(0, it) + i*lda, 1 );
}
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlaswpc_ontile_quark ( Quark *  quark)

Definition at line 516 of file core_zlaswp.c.

References A, CORE_zlaswpc_ontile(), and quark_unpack_args_7.

{
int i1, i2, inc;
int *ipiv;
PLASMA_Complex64_t *A, *fake;
PLASMA_desc descA;
quark_unpack_args_7(quark, descA, A, i1, i2, ipiv, inc, fake);
CORE_zlaswpc_ontile(descA, i1, i2, ipiv, inc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zlauum ( int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA 
)

Definition at line 29 of file core_zlauum.c.

References lapack_const.

{
LAPACKE_zlauum_work(LAPACK_COL_MAJOR, lapack_const(uplo), N, A, LDA );
}
void CORE_zlauum_quark ( Quark *  quark)

Definition at line 57 of file core_zlauum.c.

References A, lapack_const, quark_unpack_args_4, and uplo.

{
int uplo;
int N;
PLASMA_Complex64_t *A;
int LDA;
quark_unpack_args_4(quark, uplo, N, A, LDA);
LAPACKE_zlauum_work(LAPACK_COL_MAJOR, lapack_const(uplo), N, A, LDA);
}

Here is the caller graph for this function:

int CORE_zpamm ( int  op,
int  side,
int  storev,
int  M,
int  N,
int  K,
int  L,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  W,
int  LDW 
)

ZPAMM performs one of the matrix-matrix operations 

              LEFT                      RIGHT

OP PlasmaW : W = A1 + op(V) * A2 or W = A1 + A2 * op(V) OP PlasmaA2 : A2 = A2 - op(V) * W or A2 = A2 - W * op(V)

where op( V ) is one of

op( V ) = V or op( V ) = V**T or op( V ) = V**H,

A1, A2 and W are general matrices, and V is: 

  l = k: rectangle + triangle
  l < k: rectangle + trapezoid
  l = 0: rectangle

Size of V, both rowwise and columnwise, is:

side trans size

left N M x K T K x M right N K x N

T N x K

LEFT (columnwise and rowwise): 

        |    K    |                 |         M         |
     _  __________   _              _______________        _ 
        |    |    |                 |             | \

V: | | | V': |_____________|___\ K | | | M-L | | M | | | |__________________| _ |____| | _ \ | | | M - L | L | \ | | L _ \|____| _

RIGHT (columnwise and rowwise): 

    |         K         |                   |    N    |   
    _______________        _             _  __________   _
    |             | \                       |    |    |

V': |_____________|___\ N V: | | | | | | | | K-L |__________________| _ K | | | |____| | _ | K - L | L | \ | | \ | | L _ \|____| _

Arguments

Parameters:
[in]OP
    OP specifies which operation to perform:

    @arg PlasmaW  : W  = A1 + op(V) * A2  or  W  = A1 + A2 * op(V)
    @arg PlasmaA2 : A2 = A2 - op(V) * W   or  A2 = A2 - W * op(V)
[in]SIDE
    SIDE specifies whether  op( V ) multiplies A2
    or W from the left or right as follows:

    @arg PlasmaLeft  : multiply op( V ) from the left
                       OP PlasmaW  :  W  = A1 + op(V) * A2
                       OP PlasmaA2 :  A2 = A2 - op(V) * W

    @arg PlasmaRight : multiply op( V ) from the right
                       OP PlasmaW  :  W  = A1 + A2 * op(V)
                       OP PlasmaA2 :  A2 = A2 - W * op(V)
[in]STOREV
    Indicates how the vectors which define the elementary
    reflectors are stored in V:

    @arg PlasmaColumnwise
    @arg PlasmaRowwise
[in]MThe number of rows of the A1, A2 and W If SIDE is PlasmaLeft, the number of rows of op( V )
[in]NThe number of columns of the A1, A2 and W If SIDE is PlasmaRight, the number of columns of op( V )
[in]KIf SIDE is PlasmaLeft, the number of columns of op( V ) If SIDE is PlasmaRight, the number of rows of op( V )
[in]LThe size of the triangular part of V
[in]A1On entry, the M-by-N tile A1.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M).
[in,out]A2On entry, the M-by-N tile A2. On exit, if OP is PlasmaA2 A2 is overwritten
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M).
[in]VThe matrix V as described above. If SIDE is PlasmaLeft : op( V ) is M-by-K If SIDE is PlasmaRight: op( V ) is K-by-N
[in]LDVThe leading dimension of the array V.
[in,out]WOn entry, the M-by-N matrix W. On exit, W is overwritten either if OP is PlasmaA2 or PlasmaW. If OP is PlasmaA2, W is an input and is used as a workspace.
[in]LDWThe leading dimension of array WORK.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 174 of file core_zpamm.c.

References CblasLower, CblasUpper, coreblas_error, L, PLASMA_SUCCESS, PlasmaA2, PlasmaColumnwise, PlasmaConjTrans, PlasmaLeft, PlasmaNoTrans, PlasmaRight, PlasmaRowwise, PlasmaW, trans, and uplo.

{
int vi2, vi3, uplo, trans, info;
/* Check input arguments */
if ((op != PlasmaW) && (op != PlasmaA2)) {
coreblas_error(1, "Illegal value of op");
return -1;
}
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(2, "Illegal value of side");
return -2;
}
if ((storev != PlasmaColumnwise) && (storev != PlasmaRowwise)) {
coreblas_error(3, "Illegal value of storev");
return -3;
}
if (M < 0) {
coreblas_error(4, "Illegal value of M");
return -4;
}
if (N < 0) {
coreblas_error(5, "Illegal value of N");
return -5;
}
if (K < 0) {
coreblas_error(6, "Illegal value of K");
return -6;
}
if (L < 0) {
coreblas_error(7, "Illegal value of L");
return -7;
}
if (LDA1 < 0) {
coreblas_error(9, "Illegal value of LDA1");
return -9;
}
if (LDA2 < 0) {
coreblas_error(11, "Illegal value of LDA2");
return -11;
}
if (LDV < 0) {
coreblas_error(13, "Illegal value of LDV");
return -13;
}
if (LDW < 0) {
coreblas_error(15, "Illegal value of LDW");
return -15;
}
/* Quick return */
if ((M == 0) || (N == 0) || (K == 0))
return PLASMA_SUCCESS;
/*
* TRANS is set as:
*
* -------------------------------------
* side direct PlasmaW PlasmaA2
* -------------------------------------
* left colwise T N
* rowwise N T
* right colwise N T
* rowwise T N
* -------------------------------------
*/
/* Columnwise*/
if (storev == PlasmaColumnwise) {
uplo = CblasUpper;
if (side == PlasmaLeft) {
trans = op == PlasmaA2 ? PlasmaNoTrans : PlasmaConjTrans;
vi2 = trans == PlasmaNoTrans ? M - L : K - L;
}
else {
trans = op == PlasmaW ? PlasmaNoTrans : PlasmaConjTrans;
vi2 = trans == PlasmaNoTrans ? K - L : N - L;
}
vi3 = LDV * L;
}
/* Rowwise */
else {
uplo = CblasLower;
if (side == PlasmaLeft) {
trans = op == PlasmaW ? PlasmaNoTrans : PlasmaConjTrans;
vi2 = trans == PlasmaNoTrans ? K - L : M - L;
}
else {
trans = op == PlasmaA2 ? PlasmaNoTrans : PlasmaConjTrans;
vi2 = trans == PlasmaNoTrans ? N - L : K - L;
}
vi2 *= LDV;
vi3 = L;
}
if (op==PlasmaW) {
info = CORE_zpamm_w(
side, trans, uplo, M, N, K, L, vi2, vi3,
A1, LDA1, A2, LDA2, V, LDV, W, LDW);
if (info != 0)
return info;
} else if (op==PlasmaA2) {
info = CORE_zpamm_a2(
side, trans, uplo, M, N, K, L, vi2, vi3,
A2, LDA2, V, LDV, W, LDW);
if (info != 0)
return info;
}
return PLASMA_SUCCESS;
}

Here is the caller graph for this function:

void CORE_zpamm_quark ( Quark *  quark)

Definition at line 600 of file core_zpamm.c.

References CORE_zpamm(), L, quark_unpack_args_15, side, storev, V, and W.

{
int op;
int side;
int storev;
int M;
int N;
int K;
int L;
PLASMA_Complex64_t *A1;
int LDA1;
PLASMA_Complex64_t *A2;
int LDA2;
PLASMA_Complex64_t *V;
int LDV;
PLASMA_Complex64_t *W;
int LDW;
quark_unpack_args_15(quark, op, side, storev, M, N, K, L,
A1, LDA1, A2, LDA2, V, LDV, W, LDW);
CORE_zpamm( op, side, storev, M, N, K, L, A1, LDA1, A2, LDA2, V, LDV, W, LDW);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zparfb ( int  side,
int  trans,
int  direct,
int  storev,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  L,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_zparfb applies a complex upper triangular block reflector H or its transpose H' to a complex rectangular matrix formed by coupling two tiles A1 and A2. Matrix V is: 

    COLUMNWISE                    ROWWISE

   |     K     |                 |      N2-L     |   L  |
__ _____________ __           __ _________________        __
   |    |      |                 |               | \
   |    |      |                 |               |   \    L

M2-L | | | K |_______________|_____\ __ | | | M2 | | __ |____| | | | K-L \ | | __ |______________________| __ L \ | | __ \|______| __ | N2 |

| L | K-L |

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]directIndicates how H is formed from a product of elementary reflectors
  • PlasmaForward : H = H(1) H(2) . . . H(k) (Forward)
  • PlasmaBackward : H = H(k) . . . H(2) H(1) (Backward)
[in]storevIndicates how the vectors which define the elementary reflectors are stored:
  • PlasmaColumnwise
  • PlasmaRowwise
[in]M1The number of columns of the tile A1. M1 >= 0.
[in]N1The number of rows of the tile A1. N1 >= 0.
[in]M2The number of columns of the tile A2. M2 >= 0.
[in]N2The number of rows of the tile A2. N2 >= 0.
[in]KThe order of the matrix T (= the number of elementary reflectors whose product defines the block reflector).
[in]LThe size of the triangular part of V
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,N1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,N2).
[in]V(LDV,K) if STOREV = 'C' (LDV,M2) if STOREV = 'R' and SIDE = 'L' (LDV,N2) if STOREV = 'R' and SIDE = 'R' Matrix V.
[in]LDVThe leading dimension of the array V. If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M2); if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N2); if STOREV = 'R', LDV >= K.
[out]TThe triangular K-by-K matrix T in the representation of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= K.
[in,out]WORK
[in]LDWORKThe dimension of the array WORK.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 131 of file core_zparfb.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_ztrmm(), CblasColMajor, CblasLeft, CblasNonUnit, CblasRight, CblasUpper, CORE_zpamm(), coreblas_error, PLASMA_ERR_NOT_SUPPORTED, PLASMA_SUCCESS, PlasmaA2, PlasmaBackward, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, PlasmaRight, PlasmaRowwise, and PlasmaW.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t mzone = -1.0;
int j;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if ((direct != PlasmaForward) && (direct != PlasmaBackward)) {
coreblas_error(3, "Illegal value of direct");
return -3;
}
if ((storev != PlasmaColumnwise) && (storev != PlasmaRowwise)) {
coreblas_error(4, "Illegal value of storev");
return -4;
}
if (M1 < 0) {
coreblas_error(5, "Illegal value of M1");
return -5;
}
if (N1 < 0) {
coreblas_error(6, "Illegal value of N1");
return -6;
}
if ((M2 < 0) ||
( (side == PlasmaRight) && (M1 != M2) ) ) {
coreblas_error(7, "Illegal value of M2");
return -7;
}
if ((N2 < 0) ||
( (side == PlasmaLeft) && (N1 != N2) ) ) {
coreblas_error(8, "Illegal value of N2");
return -8;
}
if (K < 0) {
coreblas_error(9, "Illegal value of K");
return -9;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0))
return PLASMA_SUCCESS;
if (direct == PlasmaForward) {
if (side == PlasmaLeft) {
/*
* Column or Rowwise / Forward / Left
* ----------------------------------
*
* Form H * A or H' * A where A = ( A1 )
* ( A2 )
*/
/* W = A1 + op(V) * A2 */
CORE_zpamm(
PlasmaW, PlasmaLeft, storev,
K, N1, M2, L,
A1, LDA1,
A2, LDA2,
V, LDV,
WORK, LDWORK);
/* W = op(T) * W */
cblas_ztrmm(
CblasColMajor, CblasLeft, CblasUpper,
(CBLAS_TRANSPOSE)trans, CblasNonUnit, K, N2,
CBLAS_SADDR(zone), T, LDT, WORK, LDWORK);
/* A1 = A1 - W */
for(j = 0; j < N1; j++) {
cblas_zaxpy(
K, CBLAS_SADDR(mzone),
&WORK[LDWORK*j], 1,
&A1[LDA1*j], 1);
}
/* A2 = A2 - op(V) * W */
/* W also changes: W = V * W, A2 = A2 - W */
CORE_zpamm(
PlasmaA2, PlasmaLeft, storev,
M2, N2, K, L,
A1, LDA1,
A2, LDA2,
V, LDV,
WORK, LDWORK);
}
else {
/*
* Column or Rowwise / Forward / Right
* -----------------------------------
*
* Form H * A or H' * A where A = ( A1 A2 )
*
*/
/* W = A1 + A2 * op(V) */
CORE_zpamm(
PlasmaW, PlasmaRight, storev,
M1, K, N2, L,
A1, LDA1,
A2, LDA2,
V, LDV,
WORK, LDWORK);
/* W = W * op(T) */
cblas_ztrmm(
CblasColMajor, CblasRight, CblasUpper,
(CBLAS_TRANSPOSE)trans, CblasNonUnit, M2, K,
CBLAS_SADDR(zone), T, LDT, WORK, LDWORK);
/* A1 = A1 - W */
for(j = 0; j < K; j++) {
cblas_zaxpy(
M1, CBLAS_SADDR(mzone),
&WORK[LDWORK*j], 1,
&A1[LDA1*j], 1);
}
/* A2 = A2 - W * op(V) */
/* W also changes: W = W * V', A2 = A2 - W */
CORE_zpamm(
PlasmaA2, PlasmaRight, storev,
M2, N2, K, L,
A1, LDA1,
A2, LDA2,
V, LDV,
WORK, LDWORK);
}
}
else {
coreblas_error(3, "Not implemented (Backward / Left or Right)");
return PLASMA_ERR_NOT_SUPPORTED;
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zpemv ( int  trans,
int  storev,
int  M,
int  N,
int  L,
PLASMA_Complex64_t  ALPHA,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  X,
int  INCX,
PLASMA_Complex64_t  BETA,
PLASMA_Complex64_t *  Y,
int  INCY,
PLASMA_Complex64_t *  WORK 
)

ZPEMV performs one of the matrix-vector operations

y = alpha*op( A )*x + beta*y

where op( A ) is one of

op( A ) = A or op( A ) = A**T or op( A ) = A**H,

alpha and beta are scalars, x and y are vectors and A is a pentagonal matrix (see further details).

Arguments

Parameters:
[in]storev
    @arg PlasmaColumnwise :  array A stored columwise
    @arg PlasmaRowwise    :  array A stored rowwise
[in]trans
    @arg PlasmaNoTrans   :  y := alpha*A*x    + beta*y.
    @arg PlasmaTrans     :  y := alpha*A**T*x + beta*y.
    @arg PlasmaConjTrans :  y := alpha*A**H*x + beta*y.
[in]MNumber of rows of the matrix A. M must be at least zero.
[in]NNumber of columns of the matrix A. N must be at least zero.
[in]LOrder of triangle within the matrix A (L specifies the shape of the matrix A; see further details).
[in]ALPHAScalar alpha.
[in]AArray of size LDA-by-N. On entry, the leading M by N part of the array A must contain the matrix of coefficients.
[in]LDALeading dimension of array A.
[in]XOn entry, the incremented array X must contain the vector x.
[in]INCXIncrement for the elements of X. INCX must not be zero.
[in]BETAScalar beta.
[in,out]YOn entry, the incremented array Y must contain the vector y.
[out]INCYIncrement for the elements of Y. INCY must not be zero.
[in]WORKWorkspace array of size at least L.

Further Details

         |     N    |
      _   ___________   _
         |          |

A: | | M-L | | | | M _ |..... | \ : | L \ : | _ \:_____| _

| L | N-L |

Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 118 of file core_zpemv.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_zcopy(), cblas_zgemv(), cblas_zscal(), cblas_ztrmv(), CblasColMajor, coreblas_error, L, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaRowwise, PlasmaTrans, and PlasmaUpper.

{
/*
* y = alpha * op(A) * x + beta * y
*/
int K;
static PLASMA_Complex64_t zzero = 0.0;
/* Check input arguments */
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(1, "Illegal value of trans");
return -1;
}
if ((storev != PlasmaColumnwise) && (storev != PlasmaRowwise)) {
coreblas_error(2, "Illegal value of storev");
return -2;
}
if (!( ((storev == PlasmaColumnwise) && (trans != PlasmaNoTrans)) ||
((storev == PlasmaRowwise) && (trans == PlasmaNoTrans)) )) {
coreblas_error(2, "Illegal values of trans/storev");
return -2;
}
if (M < 0) {
coreblas_error(3, "Illegal value of M");
return -3;
}
if (N < 0) {
coreblas_error(4, "Illegal value of N");
return -4;
}
if (L > min(M ,N)) {
coreblas_error(5, "Illegal value of L");
return -5;
}
if (LDA < max(1,M)) {
coreblas_error(8, "Illegal value of LDA");
return -8;
}
if (INCX < 1) {
coreblas_error(10, "Illegal value of INCX");
return -10;
}
if (INCY < 1) {
coreblas_error(13, "Illegal value of INCY");
return -13;
}
/* Quick return */
if ((M == 0) || (N == 0))
return PLASMA_SUCCESS;
if ((ALPHA == zzero) && (BETA == zzero))
return PLASMA_SUCCESS;
/* If L < 2, there is no triangular part */
if (L == 1) L = 0;
/* Columnwise */
if (storev == PlasmaColumnwise) {
/*
* ______________
* | | | A1: A[ 0 ]
* | | | A2: A[ M-L ]
* | A1 | | A3: A[ (N-L) * LDA ]
* | | |
* |______| A3 |
* \ | |
* \ A2 | |
* \ | |
* \|_____|
*
*/
/* Columnwise / NoTrans */
if (trans == PlasmaNoTrans) {
coreblas_error(1, "The case PlasmaNoTrans / PlasmaColumnwise is not yet implemented");
return -1;
}
/* Columnwise / [Conj]Trans */
else {
/* L top rows of y */
if (L > 0) {
/* w = A_2' * x_2 */
cblas_zcopy(
L, &X[INCX*(M-L)], INCX, WORK, 1);
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)trans,
(CBLAS_DIAG)PlasmaNonUnit,
L, &A[M-L], LDA, WORK, 1);
if (M > L) {
/* y_1 = beta * y_1 [ + alpha * A_1 * x_1 ] */
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)trans,
M-L, L, CBLAS_SADDR(ALPHA), A, LDA,
X, INCX, CBLAS_SADDR(BETA), Y, INCY);
/* y_1 = y_1 + alpha * w */
cblas_zaxpy(L, CBLAS_SADDR(ALPHA), WORK, 1, Y, INCY);
} else {
/* y_1 = y_1 + alpha * w */
if (BETA == zzero) {
cblas_zscal(L, CBLAS_SADDR(ALPHA), WORK, 1);
cblas_zcopy(L, WORK, 1, Y, INCY);
} else {
cblas_zscal(L, CBLAS_SADDR(BETA), Y, INCY);
cblas_zaxpy(L, CBLAS_SADDR(ALPHA), WORK, 1, Y, INCY);
}
}
}
/* N-L bottom rows of Y */
if (N > L) {
K = N - L;
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)trans,
M, K, CBLAS_SADDR(ALPHA), &A[LDA*L], LDA,
X, INCX, CBLAS_SADDR(BETA), &Y[INCY*L], INCY);
}
}
}
/* Rowwise */
else {
/*
* --------------
* | | \ A1: A[ 0 ]
* | A1 | \ A2: A[ (N-L) * LDA ]
* | | A2 \ A3: A[ L ]
* |--------------------\
* | A3 |
* ----------------------
*
*/
/* Rowwise / NoTrans */
if (trans == PlasmaNoTrans) {
/* L top rows of A and y */
if (L > 0) {
/* w = A_2 * x_2 */
cblas_zcopy(
L, &X[INCX*(N-L)], INCX, WORK, 1);
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaLower,
(CBLAS_TRANSPOSE)PlasmaNoTrans,
(CBLAS_DIAG)PlasmaNonUnit,
L, &A[LDA*(N-L)], LDA, WORK, 1);
if (N > L) {
/* y_1 = beta * y_1 [ + alpha * A_1 * x_1 ] */
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans,
L, N-L, CBLAS_SADDR(ALPHA), A, LDA,
X, INCX, CBLAS_SADDR(BETA), Y, INCY);
/* y_1 = y_1 + alpha * w */
cblas_zaxpy(L, CBLAS_SADDR(ALPHA), WORK, 1, Y, INCY);
} else {
/* y_1 = y_1 + alpha * w */
if (BETA == zzero) {
cblas_zscal(L, CBLAS_SADDR(ALPHA), WORK, 1);
cblas_zcopy(L, WORK, 1, Y, INCY);
} else {
cblas_zscal(L, CBLAS_SADDR(BETA), Y, INCY);
cblas_zaxpy(L, CBLAS_SADDR(ALPHA), WORK, 1, Y, INCY);
}
}
}
/* M-L bottom rows of Y */
if (M > L) {
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans,
M-L, N, CBLAS_SADDR(ALPHA), &A[L], LDA,
X, INCX, CBLAS_SADDR(BETA), &Y[INCY*L], INCY);
}
}
/* Rowwise / [Conj]Trans */
else {
coreblas_error(1, "The case Plasma[Conj]Trans / PlasmaRowwise is not yet implemented");
return -1;
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zplghe ( double  bump,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 64 of file core_zplghe.c.

References A, cimag(), conj(), NBELEM, Rnd64_A, Rnd64_C, and RndF_Mul.

{
PLASMA_Complex64_t *tmp = A;
int64_t i, j;
unsigned long long int ran, jump;
jump = m0 + n0 * bigM;
/*
* Tile diagonal
*/
if ( m0 == n0 ) {
for (j = 0; j < n; j++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (i = j; i < m; i++) {
*tmp = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
*tmp += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
tmp++;
}
tmp += (lda - i + j + 1);
jump += bigM + j;
}
for (j = 0; j < n; j++) {
#ifdef COMPLEX
A[j+j*lda] += bump - I*cimag( A[j+j*lda] );
#else
A[j+j*lda] += bump;
#endif
for (i=0; i<j; i++) {
A[lda*j+i] = conj( A[lda*i+j] );
}
}
}
/*
* Lower part
*/
else if ( m0 > n0 ) {
for (j = 0; j < n; j++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (i = 0; i < m; i++) {
*tmp = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
*tmp += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
tmp++;
}
tmp += (lda - i);
jump += bigM;
}
}
/*
* Upper part
*/
else if ( m0 < n0 ) {
/* Overwrite jump */
jump = n0 + m0 * bigM;
for (i = 0; i < m; i++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (j = 0; j < n; j++) {
A[j*lda+i] = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
A[j*lda+i] -= I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
}
jump += bigM;
}
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zplghe_quark ( Quark *  quark)

Definition at line 176 of file core_zplghe.c.

References A, CORE_zplghe(), and quark_unpack_args_9.

{
double bump;
int m;
int n;
PLASMA_Complex64_t *A;
int lda;
int bigM;
int m0;
int n0;
unsigned long long int seed;
quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
CORE_zplghe( bump, m, n, A, lda, bigM, m0, n0, seed );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zplgsy ( PLASMA_Complex64_t  bump,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 64 of file core_zplgsy.c.

References A, NBELEM, Rnd64_A, Rnd64_C, and RndF_Mul.

{
PLASMA_Complex64_t *tmp = A;
int64_t i, j;
unsigned long long int ran, jump;
jump = m0 + n0 * bigM;
/*
* Tile diagonal
*/
if ( m0 == n0 ) {
for (j = 0; j < n; j++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (i = j; i < m; i++) {
*tmp = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
*tmp += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
tmp++;
}
tmp += (lda - i + j + 1);
jump += bigM + j;
}
for (j = 0; j < n; j++) {
A[j+j*lda] += bump;
for (i=0; i<j; i++) {
A[lda*j+i] = A[lda*i+j];
}
}
}
/*
* Lower part
*/
else if ( m0 > n0 ) {
for (j = 0; j < n; j++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (i = 0; i < m; i++) {
*tmp = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
*tmp += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
tmp++;
}
tmp += (lda - i);
jump += bigM;
}
}
/*
* Upper part
*/
else if ( m0 < n0 ) {
/* Overwrite jump */
jump = n0 + m0 * bigM;
for (i = 0; i < m; i++) {
ran = Rnd64_jump( NBELEM * jump, seed );
for (j = 0; j < n; j++) {
A[j*lda+i] = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
A[j*lda+i] += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
}
jump += bigM;
}
}
}

Here is the caller graph for this function:

void CORE_zplgsy_quark ( Quark *  quark)

Definition at line 172 of file core_zplgsy.c.

References A, CORE_zplgsy(), and quark_unpack_args_9.

{
PLASMA_Complex64_t bump;
int m;
int n;
PLASMA_Complex64_t *A;
int lda;
int bigM;
int m0;
int n0;
unsigned long long int seed;
quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
CORE_zplgsy( bump, m, n, A, lda, bigM, m0, n0, seed );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zplrnt ( int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 64 of file core_zplrnt.c.

References A, NBELEM, Rnd64_A, Rnd64_C, and RndF_Mul.

{
PLASMA_Complex64_t *tmp = A;
int64_t i, j;
unsigned long long int ran, jump;
jump = m0 + n0 * bigM;
for (j=0; j<n; ++j ) {
ran = Rnd64_jump( NBELEM*jump, seed );
for (i = 0; i < m; ++i) {
*tmp = 0.5f - ran * RndF_Mul;
ran = Rnd64_A * ran + Rnd64_C;
#ifdef COMPLEX
*tmp += I*(0.5f - ran * RndF_Mul);
ran = Rnd64_A * ran + Rnd64_C;
#endif
tmp++;
}
tmp += lda-i;
jump += bigM;
}
}

Here is the caller graph for this function:

void CORE_zplrnt_quark ( Quark *  quark)

Definition at line 116 of file core_zplrnt.c.

References A, CORE_zplrnt(), and quark_unpack_args_8.

{
int m;
int n;
PLASMA_Complex64_t *A;
int lda;
int bigM;
int m0;
int n0;
unsigned long long int seed;
quark_unpack_args_8( quark, m, n, A, lda, bigM, m0, n0, seed );
CORE_zplrnt( m, n, A, lda, bigM, m0, n0, seed );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zpotrf ( int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int *  INFO 
)

Definition at line 29 of file core_zpotrf.c.

References lapack_const.

{
*INFO = LAPACKE_zpotrf_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
N, A, LDA );
}

Here is the caller graph for this function:

void CORE_zpotrf_quark ( Quark *  quark)

Definition at line 65 of file core_zpotrf.c.

References A, lapack_const, plasma_sequence_flush(), PLASMA_SUCCESS, quark_unpack_args_7, plasma_sequence_t::status, and uplo.

{
int uplo;
int n;
PLASMA_Complex64_t *A;
int lda;
PLASMA_sequence *sequence;
PLASMA_request *request;
int iinfo;
int info;
quark_unpack_args_7(quark, uplo, n, A, lda, sequence, request, iinfo);
info = LAPACKE_zpotrf_work(
LAPACK_COL_MAJOR,
lapack_const(uplo),
n, A, lda);
if (sequence->status == PLASMA_SUCCESS && info != 0)
plasma_sequence_flush(quark, sequence, request, iinfo+info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zshift ( int  s,
int  m,
int  n,
int  L,
PLASMA_Complex64_t *  A 
)

CORE_zshift Shift a cycle of block. Same as core_zshiftw but you don't need to provide the workspace. As a matter of fact, the cycle cannot be split anymore to keep data coherency.

Parameters:
[in]sStart value in the cycle
[in]mNumber of lines of tile A
[in]nNumber of columns of tile A
[in]LLength of each block of data to move
[in,out]AMatrix of size m-by-n with each element of size L. On exit, A = A', where A' contains the permutations

Definition at line 175 of file core_zshift.c.

References CORE_zshiftw(), and W.

{
PLASMA_Complex64_t *W;
W = (PLASMA_Complex64_t*)malloc(L * sizeof(PLASMA_Complex64_t));
memcpy(W, &(A[s*L]), L*sizeof(PLASMA_Complex64_t));
CORE_zshiftw(s, 0, m, n, L, A, W);
free(W);
}

Here is the call graph for this function:

void CORE_zshift_quark ( Quark *  quark)

Definition at line 208 of file core_zshift.c.

References A, CORE_zshiftw(), L, quark_unpack_args_6, and W.

{
int s;
int m;
int n;
int L;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *W;
quark_unpack_args_6(quark, s, m, n, L, A, W);
memcpy(W, &(A[s*L]), L*sizeof(PLASMA_Complex64_t));
CORE_zshiftw(s, 0, m, n, L, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zshiftw ( int  s,
int  cl,
int  m,
int  n,
int  L,
PLASMA_Complex64_t *  A,
PLASMA_Complex64_t *  W 
)

CORE_zshiftw Shift a linear chain of block using a supplied workspace by following the cycle defined by: k_(i+1) = (k_i * m) % q;

Parameters:
[in]sStart value in the cycle
[in]clCycle length if cl == 0, all the permutations from the cycle are done else the cycle is split onto several threads and the number of permutation to do has to be specified to not get overlap
[in]mNumber of lines of tile A
[in]nNumber of columns of tile A
[in]LLength of each block of data to move
[in,out]AMatrix of size m-by-n with each element of size L. On exit, A = A', where A' contains the permutations
[in]WArray of size L. On entry, must contain: W(:) = A(s*L:s*L+L-1)

Definition at line 66 of file core_zshift.c.

References L.

{
int64_t k, k1;
int i, j, q, kL, k1L;
q = m * n - 1;
k = s;
if( cl != 0 ) {
for (i=1; i<cl; i++) {
k1 = (k * m) % (int64_t)q;
/* A(k*L:k*L+L-1) = A(k1*L:k1*L+L-1) */
kL = k *L;
k1L = k1*L;
for(j=0; j<L; j++) {
A[kL+j] = A[k1L+j];
}
k = k1;
}
}
else {
while (1) {
k1 = (k * m) % (int64_t)q;
if( k1 == s )
break;
/* A(k*L:k*L+L-1) = A(k1*L:k1*L+L-1) */
kL = k *L;
k1L = k1*L;
for (j=0; j<L; j++) {
A[kL+j] = A[k1L+j];
}
k = k1;
}
}
memcpy(&(A[k*L]), W, L*sizeof(PLASMA_Complex64_t));
}

Here is the caller graph for this function:

void CORE_zshiftw_quark ( Quark *  quark)

Definition at line 130 of file core_zshift.c.

References A, CORE_zshiftw(), L, quark_unpack_args_7, and W.

{
int s;
int cl;
int m;
int n;
int L;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *W;
quark_unpack_args_7(quark, s, cl, m, n, L, A, W);
CORE_zshiftw(s, cl, m, n, L, A, W);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zssssm ( int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  L1,
int  LDL1,
PLASMA_Complex64_t *  L2,
int  LDL2,
int *  IPIV 
)

CORE_ztstrf computes an LU factorization of a complex matrix formed by an upper triangular M1-by-N1 tile U on top of a M2-by-N2 tile A (N1 == N2) using partial pivoting with row interchanges.

This is the right-looking Level 2.5 BLAS version of the algorithm.

Parameters:
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0.
[in]N2The number of columns of the tile A2. N2 >= 0.
[in]KThe number of columns of the tiles L1 and L2. K >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of L.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of L.
[in]LDA2The leading dimension of the array A2. LDA2 >= max(1,M2).
[in]L1The IB-by-K lower triangular tile as returned by CORE_ztstrf.
[in]LDL1The leading dimension of the array L1. LDL1 >= max(1,IB).
[in]L2The M2-by-N2 tile as returned by CORE_ztstrf.
[in]LDL2The leading dimension of the array L2. LDL2 >= max(1,M2).
[in]IPIVas returned by CORE_ztstrf.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if INFO = -k, the k-th argument had an illegal value

Definition at line 90 of file core_zssssm.c.

References CBLAS_SADDR, cblas_zgemm(), cblas_zswap(), cblas_ztrsm(), CblasColMajor, CblasLeft, CblasLower, CblasNoTrans, CblasUnit, coreblas_error, max, min, and PLASMA_SUCCESS.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t mzone =-1.0;
int i, ii, sb;
int im, ip;
/* Check input arguments */
if (M1 < 0) {
coreblas_error(1, "Illegal value of M1");
return -1;
}
if (N1 < 0) {
coreblas_error(2, "Illegal value of N1");
return -2;
}
if (M2 < 0) {
coreblas_error(3, "Illegal value of M2");
return -3;
}
if (N2 < 0) {
coreblas_error(4, "Illegal value of N2");
return -4;
}
if (K < 0) {
coreblas_error(5, "Illegal value of K");
return -5;
}
if (IB < 0) {
coreblas_error(6, "Illegal value of IB");
return -6;
}
if (LDA1 < max(1,M1)) {
coreblas_error(8, "Illegal value of LDA1");
return -8;
}
if (LDA2 < max(1,M2)) {
coreblas_error(10, "Illegal value of LDA2");
return -10;
}
if (LDL1 < max(1,IB)) {
coreblas_error(12, "Illegal value of LDL1");
return -12;
}
if (LDL2 < max(1,M2)) {
coreblas_error(14, "Illegal value of LDL2");
return -14;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
ip = 0;
for(ii = 0; ii < K; ii += IB) {
sb = min(K-ii, IB);
for(i = 0; i < sb; i++) {
im = IPIV[ip]-1;
if (im != (ii+i)) {
im = im - M1;
cblas_zswap(N1, &A1[ii+i], LDA1, &A2[im], LDA2);
}
ip = ip + 1;
}
cblas_ztrsm(
CblasColMajor, CblasLeft, CblasLower,
CblasNoTrans, CblasUnit,
sb, N1, CBLAS_SADDR(zone),
&L1[LDL1*ii], LDL1,
&A1[ii], LDA1);
cblas_zgemm(
CblasColMajor, CblasNoTrans, CblasNoTrans,
M2, N2, sb,
CBLAS_SADDR(mzone), &L2[LDL2*ii], LDL2,
&A1[ii], LDA1,
CBLAS_SADDR(zone), A2, LDA2);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zssssm_quark ( Quark *  quark)

Definition at line 219 of file core_zssssm.c.

References CORE_zssssm(), IPIV, and quark_unpack_args_15.

{
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *L1;
int ldl1;
PLASMA_Complex64_t *L2;
int ldl2;
int *IPIV;
quark_unpack_args_15(quark, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
CORE_zssssm(m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zswpab ( int  i,
int  n1,
int  n2,
PLASMA_Complex64_t *  A,
PLASMA_Complex64_t *  work 
)

CORE_zswpab swaps two adjacent contiguous blocks of data. 

n1                     n2

+————-+——————————-+

become : n2 n1 +——————————-+————-+

Parameters:
[in,out]AArray of size i+n1+n2. On entry, a block of size n1 followed by a block of size n2. On exit, the block of size n1 follows the block of size n2.
[in]iFirst block starts at A[i].
[in]n1Size of the first block to swap.
[in]n2Size of the second block to swap.
[out]workWorkspace array of size min(n1, n2).

Definition at line 63 of file core_zswpab.c.

{
PLASMA_Complex64_t *A0 = &(A[i]);
PLASMA_Complex64_t *A1 = &(A[i+n1]);
PLASMA_Complex64_t *A2 = &(A[i+n2]);
int j;
if( n1 < n2 ) {
memcpy(work, A0, n1*sizeof(PLASMA_Complex64_t));
for (j=0; j<n2; j++)
A0[j] = A1[j];
memcpy(A2, work, n1*sizeof(PLASMA_Complex64_t));
} else {
memcpy(work, A1, n2*sizeof(PLASMA_Complex64_t));
for (j=n1-1; j>-1; j--)
A2[j] = A0[j];
memcpy(A0, work, n2*sizeof(PLASMA_Complex64_t));
}
}

Here is the caller graph for this function:

void CORE_zswpab_quark ( Quark *  quark)

Definition at line 107 of file core_zswpab.c.

References A, CORE_zswpab(), and quark_unpack_args_5.

{
int i;
int n1;
int n2;
PLASMA_Complex64_t *A;
PLASMA_Complex64_t *work;
quark_unpack_args_5(quark, i, n1, n2, A, work);
CORE_zswpab( i, n1, n2, A, work);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zswptr_ontile ( PLASMA_desc  descA,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  Akk,
int  ldak 
)

CORE_zswptr_ontile apply the zlaswp function on a matrix stored in tile layout, followed by a ztrsm on the first tile of the panel.

Parameters:
[in,out]AThe descriptor of the matrix A to permute.
[in]i1The first element of IPIV for which a row interchange will be done.
[in]i2The last element of IPIV for which a row interchange will be done.
[in]ipivThe pivot indices; Only the element in position i1 to i2 are accessed. The pivot are offset by A.i.
[in]incThe increment between successive values of IPIV. If IPIV is negative, the pivots are applied in reverse order.

Definition at line 325 of file core_zlaswp.c.

References A, BLKLDD, CBLAS_SADDR, cblas_ztrsm(), CblasColMajor, CblasLeft, CblasLower, CblasNoTrans, CblasUnit, CORE_zlaswp_ontile(), coreblas_error, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::mt, plasma_desc_t::n, plasma_desc_t::nt, and PLASMA_SUCCESS.

{
PLASMA_Complex64_t zone = 1.0;
int lda;
int m = descA.mt == 1 ? descA.m : descA.mb;
if ( descA.nt > 1 ) {
coreblas_error(1, "Illegal value of descA.nt");
return -1;
}
if ( i1 < 1 ) {
coreblas_error(2, "Illegal value of i1");
return -2;
}
if ( (i2 < i1) || (i2 > m) ) {
coreblas_error(3, "Illegal value of i2");
return -3;
}
CORE_zlaswp_ontile(descA, i1, i2, ipiv, inc);
lda = BLKLDD(descA, 0);
cblas_ztrsm( CblasColMajor, CblasLeft, CblasLower,
CblasNoTrans, CblasUnit,
m, descA.n, CBLAS_SADDR(zone),
Akk, ldak,
A(0, 0), lda );
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zswptr_ontile_quark ( Quark *  quark)

Definition at line 385 of file core_zlaswp.c.

References A, CORE_zswptr_ontile(), and quark_unpack_args_8.

{
int i1, i2, inc, ldak;
int *ipiv;
PLASMA_Complex64_t *A, *Akk;
PLASMA_desc descA;
quark_unpack_args_8(quark, descA, A, i1, i2, ipiv, inc, Akk, ldak);
CORE_zswptr_ontile(descA, i1, i2, ipiv, inc, Akk, ldak);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsymm ( int  side,
int  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 
)

Definition at line 28 of file core_zsymm.c.

References CBLAS_SADDR, cblas_zsymm(), and CblasColMajor.

{
cblas_zsymm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsymm_quark ( Quark *  quark)

Definition at line 77 of file core_zsymm.c.

References A, B, C, CBLAS_SADDR, cblas_zsymm(), CblasColMajor, quark_unpack_args_12, side, and uplo.

{
int side;
int 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;
quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
cblas_zsymm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsyr2k ( int  uplo,
int  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 
)

Definition at line 28 of file core_zsyr2k.c.

References CBLAS_SADDR, cblas_zsyr2k(), and CblasColMajor.

{
cblas_zsyr2k(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
N, K,
CBLAS_SADDR(alpha), A, LDA, B, LDB,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsyr2k_quark ( Quark *  quark)

Definition at line 76 of file core_zsyr2k.c.

References A, B, C, CORE_zsyr2k(), quark_unpack_args_12, trans, and uplo.

{
int uplo;
int 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;
quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
CORE_zsyr2k(uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsyrk ( int  uplo,
int  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 
)

Definition at line 28 of file core_zsyrk.c.

References CBLAS_SADDR, cblas_zsyrk(), and CblasColMajor.

{
cblas_zsyrk(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
N, K,
CBLAS_SADDR(alpha), A, LDA,
CBLAS_SADDR(beta), C, LDC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zsyrk_quark ( Quark *  quark)

Definition at line 72 of file core_zsyrk.c.

References A, C, CBLAS_SADDR, cblas_zsyrk(), CblasColMajor, quark_unpack_args_10, trans, and uplo.

{
int uplo;
int 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;
quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
cblas_zsyrk(
CblasColMajor,
(CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
n, k,
CBLAS_SADDR(alpha), A, lda,
CBLAS_SADDR(beta), C, ldc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrdalg ( PLASMA_enum  uplo,
int  N,
int  NB,
PLASMA_desc *  pA,
PLASMA_Complex64_t *  V,
PLASMA_Complex64_t *  TAU,
int  i,
int  j,
int  m,
int  grsiz 
)

CORE_ztrdalg is a part of the tridiagonal reduction algorithm (bulgechasing) It correspond to a local driver of the kernels that should be executed on a single core.

Parameters:
[in]uplo
  • PlasmaLower:
  • PlasmaUpper:
[in]NThe order of the matrix A. N >= 0.
[in]NBThe size of the Bandwidth of the matrix A, which correspond to the tile size. NB >= 0.
[in]pAA pointer to the descriptor of the matrix A.
[out]VPLASMA_Complex64_t array, dimension (N). The scalar elementary reflectors are written in this array. So it is used as a workspace for V at each step of the bulge chasing algorithm.
[out]TAUPLASMA_Complex64_t array, dimension (N). The scalar factors of the elementary reflectors are written in thisarray. So it is used as a workspace for TAU at each step of the bulge chasing algorithm.
[in]iInteger that refer to the current sweep. (outer loop).
[in]jInteger that refer to the sweep to chase.(inner loop).
[in]mInteger that refer to a sweep step, to ensure order dependencies.
[in]grsizInteger that refer to the size of a group. group mean the number of kernel that should be executed sequentially on the same core. group size is a trade-off between locality (cache reuse) and parallelism. a small group size increase parallelism while a large group size increase cache reuse.
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 82 of file core_ztrdalg.c.

References A, CORE_zhbelr(), CORE_zhblrx(), CORE_zhbrce(), plasma_desc_t::dtyp, min, and plasma_element_size().

{
int k, shift=3;
int myid, colpt, stind, edind, blklastind, stepercol;
size_t eltsize;
PLASMA_desc A = *pA;
eltsize = plasma_element_size(A.dtyp);
k = shift / grsiz;
stepercol = (k*grsiz == shift) ? k : k+1;
for (k = 0; k < grsiz; k++){
myid = (i-j)*(stepercol*grsiz) +(m-1)*grsiz + k+1;
if(myid%2 ==0) {
colpt = (myid/2) * NB + 1 + j - 1;
stind = colpt - NB + 1;
edind = min(colpt, N);
blklastind = colpt;
} else {
colpt = ((myid+1)/2)*NB + 1 +j -1 ;
stind = colpt-NB+1;
edind = min(colpt,N);
if( (stind>=edind-1) && (edind==N) )
blklastind = N;
else
blklastind = 0;
}
if( myid == 1 )
CORE_zhbelr(uplo, N, &A, V, TAU, stind, edind, eltsize);
else if(myid%2 == 0)
CORE_zhbrce(uplo, N, &A, V, TAU, stind, edind, eltsize);
else /*if(myid%2 == 1)*/
CORE_zhblrx(uplo, N, &A, V, TAU, stind, edind, eltsize);
if(blklastind >= (N-1)) break;
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrdalg_quark ( Quark *  quark)

Definition at line 160 of file core_ztrdalg.c.

References CORE_ztrdalg(), quark_unpack_args_10, TAU, uplo, and V.

{
PLASMA_desc *pA;
PLASMA_Complex64_t *V;
PLASMA_Complex64_t *TAU;
int uplo;
int N, NB;
int i, j, m, grsiz;
quark_unpack_args_10(quark, uplo, N, NB, pA, V, TAU, i, j, m, grsiz);
CORE_ztrdalg(uplo, N, NB, pA, V, TAU, i, j, m, grsiz);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrmm ( int  side,
int  uplo,
int  transA,
int  diag,
int  M,
int  N,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB 
)

Definition at line 28 of file core_ztrmm.c.

References CBLAS_SADDR, cblas_ztrmm(), and CblasColMajor.

{
cblas_ztrmm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
(CBLAS_TRANSPOSE)transA, (CBLAS_DIAG)diag,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB);
}

Here is the call graph for this function:

void CORE_ztrmm_p2_quark ( Quark *  quark)

Definition at line 132 of file core_ztrmm.c.

References A, B, CBLAS_SADDR, cblas_ztrmm(), CblasColMajor, diag, quark_unpack_args_11, side, and uplo.

{
int side;
int uplo;
int transA;
int diag;
int M;
int N;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t *A;
int LDA;
PLASMA_Complex64_t **B;
int LDB;
quark_unpack_args_11(quark, side, uplo, transA, diag, M, N, alpha, A, LDA, B, LDB);
cblas_ztrmm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
(CBLAS_TRANSPOSE)transA, (CBLAS_DIAG)diag,
M, N,
CBLAS_SADDR(alpha), A, LDA,
*B, LDB);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrmm_quark ( Quark *  quark)

Definition at line 76 of file core_ztrmm.c.

References A, B, CBLAS_SADDR, cblas_ztrmm(), CblasColMajor, diag, quark_unpack_args_11, side, and uplo.

{
int side;
int uplo;
int transA;
int diag;
int M;
int N;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t *A;
int LDA;
PLASMA_Complex64_t *B;
int LDB;
quark_unpack_args_11(quark, side, uplo, transA, diag, M, N, alpha, A, LDA, B, LDB);
cblas_ztrmm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
(CBLAS_TRANSPOSE)transA, (CBLAS_DIAG)diag,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrsm ( int  side,
int  uplo,
int  transA,
int  diag,
int  M,
int  N,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB 
)

Definition at line 28 of file core_ztrsm.c.

References CBLAS_SADDR, cblas_ztrsm(), and CblasColMajor.

{
cblas_ztrsm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
(CBLAS_TRANSPOSE)transA, (CBLAS_DIAG)diag,
M, N,
CBLAS_SADDR(alpha), A, LDA,
B, LDB);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrsm_quark ( Quark *  quark)

Definition at line 75 of file core_ztrsm.c.

References A, B, CBLAS_SADDR, cblas_ztrsm(), CblasColMajor, diag, quark_unpack_args_11, side, and uplo.

{
int side;
int uplo;
int transA;
int diag;
int m;
int n;
PLASMA_Complex64_t alpha;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *B;
int ldb;
quark_unpack_args_11(quark, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb);
cblas_ztrsm(
CblasColMajor,
(CBLAS_SIDE)side, (CBLAS_UPLO)uplo,
(CBLAS_TRANSPOSE)transA, (CBLAS_DIAG)diag,
m, n,
CBLAS_SADDR(alpha), A, lda,
B, ldb);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztrtri ( int  uplo,
int  diag,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int *  info 
)

Definition at line 29 of file core_ztrtri.c.

References lapack_const.

{
*info = LAPACKE_ztrtri_work(
LAPACK_COL_MAJOR,
lapack_const(uplo), lapack_const(diag),
N, A, LDA);
}
void CORE_ztrtri_quark ( Quark *  quark)

Definition at line 67 of file core_ztrtri.c.

References A, diag, lapack_const, plasma_sequence_flush(), PLASMA_SUCCESS, quark_unpack_args_8, plasma_sequence_t::status, and uplo.

{
int uplo;
int diag;
int N;
PLASMA_Complex64_t *A;
int LDA;
PLASMA_sequence *sequence;
PLASMA_request *request;
int iinfo;
int info;
quark_unpack_args_8(quark, uplo, diag, N, A, LDA, sequence, request, iinfo);
info = LAPACKE_ztrtri_work(
LAPACK_COL_MAJOR,
lapack_const(uplo), lapack_const(diag),
N, A, LDA);
if ((sequence->status == PLASMA_SUCCESS) && (info > 0))
plasma_sequence_flush(quark, sequence, request, iinfo + info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztslqt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_ztslqt computes a LQ factorization of a rectangular matrix formed by coupling side-by-side a complex M-by-M lower triangular tile A1 and a complex M-by-N tile A2:

| A1 A2 | = L * Q

The tile Q is represented as a product of elementary reflectors

Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A2(i,1:n), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A1 and A2. M >= 0. The number of columns of the tile A1.
[in]NThe number of columns of the tile A2. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M-by-M tile A1. On exit, the elements on and below the diagonal of the array contain the M-by-M lower trapezoidal tile L; the elements above the diagonal are not referenced.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M).
[in,out]A2On entry, the M-by-N tile A2. On exit, all the elements with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 107 of file core_ztslqt.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_zcopy(), cblas_zgemv(), cblas_zgerc(), cblas_ztrmv(), CblasColMajor, CORE_ztsmlq(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, and PlasmaUpper.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_Complex64_t alpha;
int i, ii, sb;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA2 < max(1,M)) && (M > 0)) {
coreblas_error(8, "Illegal value of LDA2");
return -8;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
for(ii = 0; ii < M; ii += IB) {
sb = min(M-ii, IB);
for(i = 0; i < sb; i++) {
/*
* Generate elementary reflector H( II*IB+I ) to annihilate A( II*IB+I, II*IB+I:N ).
*/
#ifdef COMPLEX
LAPACKE_zlacgv_work(N, &A2[ii+i], LDA2);
LAPACKE_zlacgv_work(1, &A1[LDA1*(ii+i)+ii+i], LDA1);
#endif
LAPACKE_zlarfg_work(N+1, &A1[LDA1*(ii+i)+ii+i], &A2[ii+i], LDA2, &TAU[ii+i]);
alpha = -(TAU[ii+i]);
if (ii+i+1 < M) {
/*
* Apply H( II+I-1 ) to A( II+I:II+IB-1, II+I-1:N ) from the right.
*/
cblas_zcopy(
sb-i-1,
&A1[LDA1*(ii+i)+(ii+i+1)], 1,
WORK, 1);
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans,
sb-i-1, N,
CBLAS_SADDR(zone), &A2[ii+i+1], LDA2,
&A2[ii+i], LDA2,
CBLAS_SADDR(zone), WORK, 1);
cblas_zaxpy(
sb-i-1, CBLAS_SADDR(alpha),
WORK, 1,
&A1[LDA1*(ii+i)+ii+i+1], 1);
cblas_zgerc(
CblasColMajor, sb-i-1, N,
CBLAS_SADDR(alpha), WORK, 1,
&A2[ii+i], LDA2,
&A2[ii+i+1], LDA2);
}
/*
* Calculate T.
*/
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans, i, N,
CBLAS_SADDR(alpha), &A2[ii], LDA2,
&A2[ii+i], LDA2,
CBLAS_SADDR(zzero), &T[LDT*(ii+i)], 1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(N, &A2[ii+i], LDA2 );
LAPACKE_zlacgv_work(1, &A1[LDA1*(ii+i)+ii+i], LDA1 );
#endif
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)PlasmaNoTrans, (CBLAS_DIAG)PlasmaNonUnit, i,
&T[LDT*ii], LDT,
&T[LDT*(ii+i)], 1);
T[LDT*(ii+i)+i] = TAU[ii+i];
}
if (M > ii+sb) {
CORE_ztsmlq(
PlasmaRight, PlasmaConjTrans,
M-(ii+sb), sb, M-(ii+sb), N, IB, IB,
&A1[LDA1*ii+ii+sb], LDA1,
&A2[ii+sb], LDA2,
&A2[ii], LDA2,
&T[LDT*ii], LDT,
WORK, LDA1);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztslqt_quark ( Quark *  quark)

Definition at line 247 of file core_ztslqt.c.

References CORE_ztslqt(), quark_unpack_args_11, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
CORE_ztslqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmlq ( int  side,
int  trans,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_ztsmlq overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 with 

                  SIDE = 'L'        SIDE = 'R'

TRANS = 'N': Q * | A1 | | A1 A2 | * Q | A2 |

TRANS = 'C': Q**H * | A1 | | A1 A2 | * Q**H | A2 |

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(k)' . . . H(2)' H(1)'

as returned by CORE_ZTSLQT.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]N2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-M1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]LDWORKThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,N1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 124 of file core_ztsmlq.c.

References CORE_zparfb(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, PlasmaRight, and PlasmaRowwise.

{
int i, i1, i3;
int NW;
int kb;
int ic = 0;
int jc = 0;
int mi = M1;
int ni = N1;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/* NW is the minimum dimension of WORK */
if (side == PlasmaLeft) {
NW = IB;
}
else {
NW = N1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M1 < 0) {
coreblas_error(3, "Illegal value of M1");
return -3;
}
if (N1 < 0) {
coreblas_error(4, "Illegal value of N1");
return -4;
}
if ( (M2 < 0) ||
( (M2 != M1) && (side == PlasmaRight) ) ){
coreblas_error(5, "Illegal value of M2");
return -5;
}
if ( (N2 < 0) ||
( (N2 != N1) && (side == PlasmaLeft) ) ){
coreblas_error(6, "Illegal value of N2");
return -6;
}
if ((K < 0) ||
( (side == PlasmaLeft) && (K > M1) ) ||
( (side == PlasmaRight) && (K > N1) ) ) {
coreblas_error(7, "Illegal value of K");
return -7;
}
if (IB < 0) {
coreblas_error(8, "Illegal value of IB");
return -8;
}
if (LDA1 < max(1,M1)){
coreblas_error(10, "Illegal value of LDA1");
return -10;
}
if (LDA2 < max(1,M2)){
coreblas_error(12, "Illegal value of LDA2");
return -12;
}
if (LDV < max(1,K)){
coreblas_error(14, "Illegal value of LDV");
return -14;
}
if (LDT < max(1,IB)){
coreblas_error(16, "Illegal value of LDT");
return -16;
}
if (LDWORK < max(1,NW)){
coreblas_error(18, "Illegal value of LDWORK");
return -18;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans == PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans != PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ((K-1) / IB)*IB;
i3 = -IB;
}
if (trans == PlasmaNoTrans) {
trans = PlasmaConjTrans;
}
else {
trans = PlasmaNoTrans;
}
for(i = i1; (i > -1) && (i < K); i += i3) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
/*
* H or H' is applied to C(i:m,1:n)
*/
mi = M1 - i;
ic = i;
}
else {
/*
* H or H' is applied to C(1:m,i:n)
*/
ni = N1 - i;
jc = i;
}
/*
* Apply H or H' (NOTE: CORE_zparfb used to be CORE_ztsrfb)
*/
CORE_zparfb(
side, trans, PlasmaForward, PlasmaRowwise,
mi, ni, M2, N2, kb, 0,
&A1[LDA1*jc+ic], LDA1,
A2, LDA2,
&V[i], LDV,
&T[LDT*i], LDT,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmlq_corner ( int  m1,
int  n1,
int  m2,
int  n2,
int  m3,
int  n3,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  A3,
int  lda3,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  WORK,
int  ldwork 
)

CORE_ztsmlq_corner: see CORE_ztsmlq

This kernel applies left and right transformations as depicted below: |I -VTV'| * | A1 A2 | * |I - VT'V'| | A2' A3 | where A1 and A3 are symmetric matrices. Only the lower part is referenced. This is an adhoc implementation, can be further optimized...

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]N2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-M1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]LDWORKThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,N1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 125 of file core_ztsmlq_corner.c.

References conj(), CORE_ztsmlq(), coreblas_error, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaNoTrans, PlasmaRight, side, and trans.

{
PLASMA_enum side;
PLASMA_enum trans;
int i, j;
if ( m1 != n1 ) {
coreblas_error(1, "Illegal value of M1, N1");
return -1;
}
/* Rebuild the symmetric block: WORK <- A1 */
for (i = 0; i < m1; i++)
for (j = i; j < n1; j++){
*(WORK + i + j*ldwork) = *(A1 + i + j*lda1);
if (j > i){
*(WORK + j + i*ldwork) = conj( *(WORK + i + j*ldwork) );
}
}
/* Copy the transpose of A2: WORK+nb*ldwork <- A2' */
for (j = 0; j < n2; j++)
for (i = 0; i < m2; i++){
*(WORK + j + (i + nb) * ldwork) = conj( *(A2 + i + j*lda2) );
}
side = PlasmaRight;
trans = PlasmaConjTrans;
/* Right application on |A1 A2| */
CORE_ztsmlq(side, trans, m1, n1, m2, n2, k, ib,
WORK, ldwork, A2, lda2,
V, ldv, T, ldt,
WORK+3*nb*ldwork, ldwork);
/* Rebuild the symmetric block: WORK+2*nb*ldwork <- A3 */
for (i = 0; i < m3; i++)
for (j = i; j < n3; j++){
*(WORK + i + (j + 2*nb) * ldwork) = *(A3 + i + j*lda3);
if (j > i){
*(WORK + j + (i + 2*nb) * ldwork) = conj ( *(WORK + i + (j + 2*nb) * ldwork) );
}
}
/* Right application on | A2' A3 | */
CORE_ztsmlq(side, trans, n2, m2, m3, n3, k, ib,
WORK+nb*ldwork, ldwork, WORK+2*nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
side = PlasmaLeft;
trans = PlasmaNoTrans;
/* Left application on | A1 | */
/* | A2' | */
CORE_ztsmlq(side, trans, m1, n1, n2, m2, k, ib,
WORK, ldwork, WORK+nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
/* Copy back the final result to the upper part of A1 */
/* A1 = WORK */
for (i = 0; i < m1; i++)
for (j = i; j < n1; j++)
*(A1 + i + j*lda1) = *(WORK + i + j*ldwork);
/* Left application on | A2 | */
/* | A3 | */
CORE_ztsmlq(side, trans, m2, n2, m3, n3, k, ib,
A2, lda2, WORK+2*nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
/* Copy back the final result to the upper part of A3 */
/* A3 = WORK+2*nb*ldwork */
for (i = 0; i < m3; i++)
for (j = i; j < n3; j++)
*(A3 + i + j*lda3) = *(WORK + i + (j+ 2*nb) * ldwork);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmlq_corner_quark ( Quark *  quark)

This kernel applies right and left transformations as depicted below: |I -VTV'| * | A1 A2| * |I - VT'V'| | A2' A3 | where A1 and A3 are symmetric matrices. Only the upper part is referenced. This is an adhoc implementation, can be further optimized...

Definition at line 266 of file core_ztsmlq_corner.c.

References CORE_ztsmlq_corner(), quark_unpack_args_21, T, and V.

{
int m1;
int n1;
int m2;
int n2;
int m3;
int n3;
int k;
int ib;
int nb;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *A3;
int lda3;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_21(quark, m1, n1, m2, n2, m3, n3, k, ib, nb,
A1, lda1, A2, lda2, A3, lda3, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmlq_corner(m1, n1, m2, n2, m3, n3, k, ib, nb,
A1, lda1, A2, lda2, A3, lda3, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmlq_hetra1 ( int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  WORK,
int  ldwork 
)

CORE_ztsmlq_hetra1: see CORE_ztsmlq

This kernel applies a Right transformation on | A1' A2 | and does not handle the transpose of A1. Needs therefore to make the explicit transpose of A1 before and after the application of the block of reflectors Can be further optimized by changing accordingly the underneath kernel ztsrfb!

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]N2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSLQT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-M1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]LDWORKThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,N1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 125 of file core_ztsmlq_hetra1.c.

References conj(), CORE_ztsmlq(), coreblas_error, and PLASMA_SUCCESS.

{
int i, j;
if ( (m1 != n1) ) {
coreblas_error(3, "Illegal value of M1, N1");
return -3;
}
/* in-place transposition of A1 */
for (j = 0; j < n1; j++){
A1[j + j*lda1] = conj(A1[j + j*lda1]);
for (i = j+1; i < m1; i++){
*WORK = *(A1 + i + j*lda1);
*(A1 + i + j*lda1) = conj(*(A1 + j + i*lda1));
*(A1 + j + i*lda1) = conj(*WORK);
}
}
CORE_ztsmlq(side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2,
V, ldv, T, ldt,
WORK, ldwork);
/* in-place transposition of A1 */
for (j = 0; j < n1; j++){
A1[j + j*lda1] = conj(A1[j + j*lda1]);
for (i = j+1; i < m1; i++){
*WORK = *(A1 + i + j*lda1);
*(A1 + i + j*lda1) = conj(*(A1 + j + i*lda1));
*(A1 + j + i*lda1) = conj(*WORK);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmlq_hetra1_quark ( Quark *  quark)

This kernel applies a Right transformation on | A1' A2 | and does not handle the transpose of A1. Needs therefore to make the explicit transpose of A1 before and after the application of the block of reflectors Can be further optimized by changing accordingly the underneath kernel ztsrfb!

Definition at line 218 of file core_ztsmlq_hetra1.c.

References CORE_ztsmlq_hetra1(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmlq_hetra1(side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmlq_quark ( Quark *  quark)

Definition at line 303 of file core_ztsmlq.c.

References CORE_ztsmlq(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmlq(side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmqr ( int  side,
int  trans,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_ztsmqr overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 with 

                  SIDE = 'L'        SIDE = 'R'

TRANS = 'N': Q * | A1 | | A1 A2 | * Q | A2 |

TRANS = 'C': Q**H * | A1 | | A1 A2 | * Q**H | A2 |

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_ZTSQRT.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]N2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]LDWORKThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 124 of file core_ztsmqr.c.

References CORE_zparfb(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, and PlasmaRight.

{
int i, i1, i3;
int NQ, NW;
int kb;
int ic = 0;
int jc = 0;
int mi = M1;
int ni = N1;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/* NQ is the order of Q */
if (side == PlasmaLeft) {
NQ = M2;
NW = IB;
}
else {
NQ = N2;
NW = M1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M1 < 0) {
coreblas_error(3, "Illegal value of M1");
return -3;
}
if (N1 < 0) {
coreblas_error(4, "Illegal value of N1");
return -4;
}
if ( (M2 < 0) ||
( (M2 != M1) && (side == PlasmaRight) ) ){
coreblas_error(5, "Illegal value of M2");
return -5;
}
if ( (N2 < 0) ||
( (N2 != N1) && (side == PlasmaLeft) ) ){
coreblas_error(6, "Illegal value of N2");
return -6;
}
if ((K < 0) ||
( (side == PlasmaLeft) && (K > M1) ) ||
( (side == PlasmaRight) && (K > N1) ) ) {
coreblas_error(7, "Illegal value of K");
return -7;
}
if (IB < 0) {
coreblas_error(8, "Illegal value of IB");
return -8;
}
if (LDA1 < max(1,M1)){
coreblas_error(10, "Illegal value of LDA1");
return -10;
}
if (LDA2 < max(1,M2)){
coreblas_error(12, "Illegal value of LDA2");
return -12;
}
if (LDV < max(1,NQ)){
coreblas_error(14, "Illegal value of LDV");
return -14;
}
if (LDT < max(1,IB)){
coreblas_error(16, "Illegal value of LDT");
return -16;
}
if (LDWORK < max(1,NW)){
coreblas_error(18, "Illegal value of LDWORK");
return -18;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans != PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans == PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ((K-1) / IB)*IB;
i3 = -IB;
}
for(i = i1; (i > -1) && (i < K); i += i3) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
/*
* H or H' is applied to C(i:m,1:n)
*/
mi = M1 - i;
ic = i;
}
else {
/*
* H or H' is applied to C(1:m,i:n)
*/
ni = N1 - i;
jc = i;
}
/*
* Apply H or H' (NOTE: CORE_zparfb used to be CORE_ztsrfb)
*/
CORE_zparfb(
side, trans, PlasmaForward, PlasmaColumnwise,
mi, ni, M2, N2, kb, 0,
&A1[LDA1*jc+ic], LDA1,
A2, LDA2,
&V[LDV*i], LDV,
&T[LDT*i], LDT,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmqr_corner ( int  m1,
int  n1,
int  m2,
int  n2,
int  m3,
int  n3,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  A3,
int  lda3,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  WORK,
int  ldwork 
)

CORE_ztsmqr_corner: see CORE_ztsmqr

This kernel applies left and right transformations as depicted below: |I -VT'V'| * | A1 A2'| * |I - VTV'| | A2 A3 | where A1 and A3 are symmetric matrices. Only the lower part is referenced. This is an adhoc implementation, can be further optimized...

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]N2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]LDWORKThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 125 of file core_ztsmqr_corner.c.

References conj(), CORE_ztsmqr(), coreblas_error, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaNoTrans, PlasmaRight, side, and trans.

{
int i, j;
PLASMA_enum side, trans;
if ( m1 != n1 ) {
coreblas_error(1, "Illegal value of M1, N1");
return -1;
}
/* Rebuild the symmetric block: WORK <- A1 */
for (j = 0; j < n1; j++)
for (i = j; i < m1; i++){
*(WORK + i + j*ldwork) = *(A1 + i + j*lda1);
if (i > j){
*(WORK + j + i*ldwork) = conj( *(WORK + i + j*ldwork) );
}
}
/* Copy the transpose of A2: WORK+nb*ldwork <- A2' */
for (j = 0; j < n2; j++)
for (i = 0; i < m2; i++){
*(WORK + j + (i + nb) * ldwork) = conj( *(A2 + i + j*lda2) );
}
side = PlasmaLeft;
trans = PlasmaConjTrans;
/* Left application on |A1| */
/* |A2| */
CORE_ztsmqr(side, trans, m1, n1, m2, n2, k, ib,
WORK, ldwork, A2, lda2,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
/* Rebuild the symmetric block: WORK+2*nb*ldwork <- A3 */
for (j = 0; j < n3; j++)
for (i = j; i < m3; i++){
*(WORK + i + (j + 2*nb) * ldwork) = *(A3 + i + j*lda3);
if (i != j){
*(WORK + j + (i + 2*nb) * ldwork) = conj( *(WORK + i + (j + 2*nb) * ldwork) );
}
}
/* Left application on | A2'| */
/* | A3 | */
CORE_ztsmqr(side, trans, n2, m2, m3, n3, k, ib,
WORK+nb*ldwork, ldwork, WORK+2*nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
side = PlasmaRight;
trans = PlasmaNoTrans;
/* Right application on | A1 A2' | */
CORE_ztsmqr(side, trans, m1, n1, n2, m2, k, ib,
WORK, ldwork, WORK+nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
/* Copy back the final result to the lower part of A1 */
/* A1 = WORK */
for (j = 0; j < n1; j++)
for (i = j; i < m1; i++)
*(A1 + i + j*lda1) = *(WORK + i + j*ldwork);
/* Right application on | A2 A3 | */
CORE_ztsmqr(side, trans, m2, n2, m3, n3, k, ib,
A2, lda2, WORK+2*nb*ldwork, ldwork,
V, ldv, T, ldt,
WORK + 3*nb*ldwork, ldwork);
/* Copy back the final result to the lower part of A3 */
/* A3 = WORK+2*nb*ldwork */
for (j = 0; j < n3; j++)
for (i = j; i < m3; i++)
*(A3 + i + j*lda3) = *(WORK + i + (j+ 2*nb) * ldwork);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmqr_corner_quark ( Quark *  quark)

Definition at line 254 of file core_ztsmqr_corner.c.

References CORE_ztsmqr_corner(), quark_unpack_args_21, T, and V.

{
int m1;
int n1;
int m2;
int n2;
int m3;
int n3;
int k;
int ib;
int nb;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *A3;
int lda3;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_21(quark, m1, n1, m2, n2, m3, n3, k, ib, nb,
A1, lda1, A2, lda2, A3, lda3, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmqr_corner(m1, n1, m2, n2, m3, n3, k, ib, nb,
A1, lda1, A2, lda2, A3, lda3, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsmqr_hetra1 ( int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  WORK,
int  ldwork 
)

CORE_ztsmqr_hetra1: see CORE_ztsmqr

This kernel applies a left transformation on | A1'| | A2 |

Needs therefore to make the explicit transpose of A1 before and after the application of the block of reflectors Can be further optimized by changing accordingly the underneath kernel ztsrfb!

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]m1The number of rows of the tile A1. M1 >= 0.
[in]n1The number of columns of the tile A1. N1 >= 0.
[in]m2The number of rows of the tile A2. M2 >= 0. M2 = M1 if side == PlasmaRight.
[in]n2The number of columns of the tile A2. N2 >= 0. N2 = N1 if side == PlasmaLeft.
[in]kThe number of elementary reflectors whose product defines the matrix Q.
[in]ibThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]lda1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]lda2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTSQRT in the first k columns of its array argument V.
[in]ldvThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]ldtThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-N1 if side == PlasmaLeft LDWORK-by-IB if side == PlasmaRight
[in]ldworkThe leading dimension of the array WORK. LDWORK >= max(1,IB) if side == PlasmaLeft LDWORK >= max(1,M1) if side == PlasmaRight
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 127 of file core_ztsmqr_hetra1.c.

References conj(), CORE_ztsmqr(), coreblas_error, and PLASMA_SUCCESS.

{
int i, j;
if ( (m1 != n1) ) {
coreblas_error(3, "Illegal value of M1, N1");
return -3;
}
/* in-place transposition of A1 */
for (j = 0; j < n1; j++){
A1[j + j*lda1] = conj(A1[j + j*lda1]);
for (i = j+1; i < m1; i++){
*WORK = *(A1 + i + j*lda1);
*(A1 + i + j*lda1) = conj(*(A1 + j + i*lda1));
*(A1 + j + i*lda1) = conj(*WORK);
}
}
CORE_ztsmqr(side, trans, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
/* in-place transposition of A1 */
for (j = 0; j < n1; j++){
A1[j + j*lda1] = conj(A1[j + j*lda1]);
for (i = j+1; i < m1; i++){
*WORK = *(A1 + i + j*lda1);
*(A1 + i + j*lda1) = conj(*(A1 + j + i*lda1));
*(A1 + j + i*lda1) = conj(*WORK);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmqr_hetra1_quark ( Quark *  quark)

Definition at line 212 of file core_ztsmqr_hetra1.c.

References CORE_ztsmqr_hetra1(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmqr_hetra1(side, trans, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsmqr_quark ( Quark *  quark)

Definition at line 298 of file core_ztsmqr.c.

References CORE_ztsmqr(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_ztsmqr(side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztsqrt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_ztsqrt computes a QR factorization of a rectangular matrix formed by coupling a complex N-by-N upper triangular tile A1 on top of a complex M-by-N tile A2:

| A1 | = Q * R | A2 |

Parameters:
[in]MThe number of columns of the tile A2. M >= 0.
[in]NThe number of rows of the tile A1. The number of columns of the tiles A1 and A2. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the N-by-N tile A1. On exit, the elements on and above the diagonal of the array contain the N-by-N upper trapezoidal tile R; the elements below the diagonal are not referenced.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,N).
[in,out]A2On entry, the M-by-N tile A2. On exit, all the elements with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 97 of file core_ztsqrt.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_zcopy(), cblas_zgemv(), cblas_zgerc(), cblas_ztrmv(), CblasColMajor, conj(), CORE_ztsmqr(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, and PlasmaUpper.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_Complex64_t alpha;
int i, ii, sb;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA2 < max(1,M)) && (M > 0)) {
coreblas_error(8, "Illegal value of LDA2");
return -8;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
for(ii = 0; ii < N; ii += IB) {
sb = min(N-ii, IB);
for(i = 0; i < sb; i++) {
/*
* Generate elementary reflector H( II*IB+I ) to annihilate
* A( II*IB+I:M, II*IB+I )
*/
LAPACKE_zlarfg_work(M+1, &A1[LDA1*(ii+i)+ii+i], &A2[LDA2*(ii+i)], 1, &TAU[ii+i]);
if (ii+i+1 < N) {
/*
* Apply H( II*IB+I ) to A( II*IB+I:M, II*IB+I+1:II*IB+IB ) from the left
*/
alpha = -conj(TAU[ii+i]);
cblas_zcopy(
sb-i-1,
&A1[LDA1*(ii+i+1)+(ii+i)], LDA1,
WORK, 1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(sb-i-1, WORK, 1);
#endif
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaConjTrans,
M, sb-i-1,
CBLAS_SADDR(zone), &A2[LDA2*(ii+i+1)], LDA2,
&A2[LDA2*(ii+i)], 1,
CBLAS_SADDR(zone), WORK, 1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(sb-i-1, WORK, 1 );
#endif
cblas_zaxpy(
sb-i-1, CBLAS_SADDR(alpha),
WORK, 1,
&A1[LDA1*(ii+i+1)+ii+i], LDA1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(sb-i-1, WORK, 1 );
#endif
cblas_zgerc(
CblasColMajor, M, sb-i-1, CBLAS_SADDR(alpha),
&A2[LDA2*(ii+i)], 1,
WORK, 1,
&A2[LDA2*(ii+i+1)], LDA2);
}
/*
* Calculate T
*/
alpha = -TAU[ii+i];
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaConjTrans, M, i,
CBLAS_SADDR(alpha), &A2[LDA2*ii], LDA2,
&A2[LDA2*(ii+i)], 1,
CBLAS_SADDR(zzero), &T[LDT*(ii+i)], 1);
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)PlasmaNoTrans, (CBLAS_DIAG)PlasmaNonUnit, i,
&T[LDT*ii], LDT,
&T[LDT*(ii+i)], 1);
T[LDT*(ii+i)+i] = TAU[ii+i];
}
if (N > ii+sb) {
CORE_ztsmqr(
PlasmaLeft, PlasmaConjTrans,
sb, N-(ii+sb), M, N-(ii+sb), IB, IB,
&A1[LDA1*(ii+sb)+ii], LDA1,
&A2[LDA2*(ii+sb)], LDA2,
&A2[LDA2*ii], LDA2,
&T[LDT*ii], LDT,
WORK, sb);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztsqrt_quark ( Quark *  quark)

Definition at line 238 of file core_ztsqrt.c.

References CORE_ztsqrt(), quark_unpack_args_11, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
CORE_ztsqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_ztstrf ( int  M,
int  N,
int  IB,
int  NB,
PLASMA_Complex64_t *  U,
int  LDU,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  L,
int  LDL,
int *  IPIV,
PLASMA_Complex64_t *  WORK,
int  LDWORK,
int *  INFO 
)

CORE_ztstrf computes an LU factorization of a complex matrix formed by an upper triangular NB-by-N tile U on top of a M-by-N tile A using partial pivoting with row interchanges.

This is the right-looking Level 2.5 BLAS version of the algorithm.

Parameters:
[in]MThe number of rows of the tile A. M >= 0.
[in]NThe number of columns of the tile A. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in]NB
[in,out]UOn entry, the NB-by-N upper triangular tile. On exit, the new factor U from the factorization
[in]LDUThe leading dimension of the array U. LDU >= max(1,NB).
[in,out]AOn entry, the M-by-N tile to be factored. On exit, the factor L from the factorization
[in]LDAThe leading dimension of the array A. LDA >= max(1,M).
[in,out]LOn entry, the IB-by-N lower triangular tile. On exit, the interchanged rows form the tile A in case of pivoting.
[in]LDLThe leading dimension of the array L. LDL >= max(1,IB).
[out]IPIVThe pivot indices; for 1 <= i <= min(M,N), row i of the tile U was interchanged with row IPIV(i) of the tile A.
[in,out]WORK
[in]LDWORKThe dimension of the array WORK.
[out]INFO
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if INFO = -k, the k-th argument had an illegal value
>0if INFO = k, U(k,k) 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.

Definition at line 99 of file core_ztstrf.c.

References cabs(), cblas_izamax(), CBLAS_SADDR, cblas_zcopy(), cblas_zgeru(), cblas_zscal(), cblas_zswap(), CblasColMajor, CORE_zssssm(), coreblas_error, max, min, and PLASMA_SUCCESS.

{
static PLASMA_Complex64_t zzero = 0.0;
static PLASMA_Complex64_t mzone =-1.0;
PLASMA_Complex64_t alpha;
int i, j, ii, sb;
int im, ip;
/* Check input arguments */
*INFO = 0;
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDU < max(1,NB)) && (NB > 0)) {
coreblas_error(6, "Illegal value of LDU");
return -6;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(8, "Illegal value of LDA");
return -8;
}
if ((LDL < max(1,IB)) && (IB > 0)) {
coreblas_error(10, "Illegal value of LDL");
return -10;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
/* Set L to 0 */
memset(L, 0, LDL*N*sizeof(PLASMA_Complex64_t));
ip = 0;
for (ii = 0; ii < N; ii += IB) {
sb = min(N-ii, IB);
for (i = 0; i < sb; i++) {
im = cblas_izamax(M, &A[LDA*(ii+i)], 1);
IPIV[ip] = ii+i+1;
if (cabs(A[LDA*(ii+i)+im]) > cabs(U[LDU*(ii+i)+ii+i])) {
/*
* Swap behind.
*/
cblas_zswap(i, &L[LDL*ii+i], LDL, &WORK[im], LDWORK );
/*
* Swap ahead.
*/
cblas_zswap(sb-i, &U[LDU*(ii+i)+ii+i], LDU, &A[LDA*(ii+i)+im], LDA );
/*
* Set IPIV.
*/
IPIV[ip] = NB + im + 1;
for (j = 0; j < i; j++) {
A[LDA*(ii+j)+im] = zzero;
}
}
if ((*INFO == 0) && (cabs(A[LDA*(ii+i)+im]) == zzero)
&& (cabs(U[LDU*(ii+i)+ii+i]) == zzero)) {
*INFO = ii+i+1;
}
alpha = ((PLASMA_Complex64_t)1. / U[LDU*(ii+i)+ii+i]);
cblas_zscal(M, CBLAS_SADDR(alpha), &A[LDA*(ii+i)], 1);
cblas_zcopy(M, &A[LDA*(ii+i)], 1, &WORK[LDWORK*i], 1);
cblas_zgeru(
CblasColMajor, M, sb-i-1,
CBLAS_SADDR(mzone), &A[LDA*(ii+i)], 1,
&U[LDU*(ii+i+1)+ii+i], LDU,
&A[LDA*(ii+i+1)], LDA );
ip = ip+1;
}
/*
* Apply the subpanel to the rest of the panel.
*/
if(ii+i < N) {
for(j = ii; j < ii+sb; j++) {
if (IPIV[j] <= NB) {
IPIV[j] = IPIV[j] - ii;
}
}
CORE_zssssm(
NB, N-(ii+sb), M, N-(ii+sb), sb, sb,
&U[LDU*(ii+sb)+ii], LDU,
&A[LDA*(ii+sb)], LDA,
&L[LDL*ii], LDL,
WORK, LDWORK, &IPIV[ii]);
for(j = ii; j < ii+sb; j++) {
if (IPIV[j] <= NB) {
IPIV[j] = IPIV[j] + ii;
}
}
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_ztstrf_quark ( Quark *  quark)

Definition at line 258 of file core_ztstrf.c.

References A, CORE_ztstrf(), IPIV, L, plasma_sequence_flush(), PLASMA_SUCCESS, and quark_unpack_args_17.

{
int m;
int n;
int ib;
int nb;
PLASMA_Complex64_t *U;
int ldu;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *L;
int ldl;
int *IPIV;
PLASMA_Complex64_t *WORK;
int ldwork;
PLASMA_sequence *sequence;
PLASMA_request *request;
PLASMA_bool check_info;
int iinfo;
int info;
quark_unpack_args_17(quark, m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, sequence, request, check_info, iinfo);
CORE_ztstrf(m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, &info);
if (info != PLASMA_SUCCESS && check_info)
plasma_sequence_flush(quark, sequence, request, iinfo + info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zttlqt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_zttlqt computes a LQ factorization of a rectangular matrix formed by coupling side-by-side a complex M-by-M lower triangular tile A1 and a complex M-by-N lower triangular tile A2:

| A1 A2 | = L * Q

The tile Q is represented as a product of elementary reflectors

Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; conjg(v(i+1:n)) is stored on exit in A2(i,1:n), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A1 and A2. M >= 0. The number of columns of the tile A1.
[in]NThe number of columns of the tile A2. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M-by-M tile A1. On exit, the elements on and below the diagonal of the array contain the M-by-M lower trapezoidal tile L; the elements above the diagonal are not referenced.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,N).
[in,out]A2On entry, the M-by-N lower triangular tile A2. On exit, the elements on and below the diagonal of the array with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDA2The leading dimension of the array A2. LDA2 >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[in,out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 100 of file core_zttlqt.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_zcopy(), cblas_zgemv(), cblas_zgerc(), cblas_ztrmv(), CblasColMajor, CORE_zlaset(), CORE_zparfb(), CORE_zpemv(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaForward, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, PlasmaRowwise, PlasmaUpper, and PlasmaUpperLower.

{
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t zzero = 0.0;
#ifdef COMPLEX
static int ione = 1;
#endif
PLASMA_Complex64_t alpha;
int i, j, l, ii, sb, mi, ni;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA2 < max(1,M)) && (M > 0)) {
coreblas_error(7, "Illegal value of LDA2");
return -7;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
/* TODO: Need to check why some cases require
* this to not have uninitialized values */
CORE_zlaset( PlasmaUpperLower, IB, N,
0., 0., T, LDT);
for(ii = 0; ii < M; ii += IB) {
sb = min(M-ii, IB);
for(i = 0; i < sb; i++) {
j = ii + i;
mi = sb-i-1;
ni = min( j + 1, N);
/*
* Generate elementary reflector H( II*IB+I ) to annihilate A( II*IB+I, II*IB+I:M ).
*/
#ifdef COMPLEX
LAPACKE_zlacgv_work(ni, &A2[j], LDA2);
LAPACKE_zlacgv_work(ione, &A1[LDA1*j+j], LDA1);
#endif
LAPACKE_zlarfg_work(ni+1, &A1[LDA1*j+j], &A2[j], LDA2, &TAU[j]);
if (mi > 0) {
/*
* Apply H( j-1 ) to A( j:II+IB-1, j-1:M ) from the right.
*/
cblas_zcopy(
mi,
&A1[LDA1*j+(j+1)], 1,
WORK, 1);
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans,
mi, ni,
CBLAS_SADDR(zone), &A2[j+1], LDA2,
&A2[j], LDA2,
CBLAS_SADDR(zone), WORK, 1);
alpha = -(TAU[j]);
cblas_zaxpy(
mi, CBLAS_SADDR(alpha),
WORK, 1,
&A1[LDA1*j+j+1], 1);
cblas_zgerc(
CblasColMajor, mi, ni,
CBLAS_SADDR(alpha), WORK, 1,
&A2[j], LDA2,
&A2[j+1], LDA2);
}
/*
* Calculate T.
*/
if (i > 0 ) {
l = min(i, max(0, N-ii));
alpha = -(TAU[j]);
CORE_zpemv(
PlasmaNoTrans, PlasmaRowwise,
i , min(j, N), l,
alpha, &A2[ii], LDA2,
&A2[j], LDA2,
zzero, &T[LDT*j], 1,
WORK);
/* T(0:i-1, j) = T(0:i-1, ii:j-1) * T(0:i-1, j) */
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)PlasmaNoTrans,
(CBLAS_DIAG)PlasmaNonUnit,
i, &T[LDT*ii], LDT,
&T[LDT*j], 1);
}
#ifdef COMPLEX
LAPACKE_zlacgv_work(ni, &A2[j], LDA2 );
LAPACKE_zlacgv_work(ione, &A1[LDA1*j+j], LDA1 );
#endif
T[LDT*j+i] = TAU[j];
}
/* Apply Q to the rest of the matrix to the right */
if (M > ii+sb) {
mi = M-(ii+sb);
ni = min(ii+sb, N);
l = min(sb, max(0, ni-ii));
CORE_zparfb(
PlasmaRight, PlasmaNoTrans,
PlasmaForward, PlasmaRowwise,
mi, IB, mi, ni, sb, l,
&A1[LDA1*ii+ii+sb], LDA1,
&A2[ii+sb], LDA2,
&A2[ii], LDA2,
&T[LDT*ii], LDT,
WORK, M);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zttlqt_quark ( Quark *  quark)

Definition at line 273 of file core_zttlqt.c.

References CORE_zttlqt(), quark_unpack_args_11, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
CORE_zttlqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zttmlq ( int  side,
int  trans,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_zttmlq overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 (N1 == N2) with 

                  SIDE = 'L'        SIDE = 'R'

TRANS = 'N': Q * | A1 | | A1 | * Q | A2 | | A2 |

TRANS = 'C': Q**H * | A1 | | A1 | * Q**H | A2 | | A2 |

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_zttqrt.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0.
[in]N2The number of columns of the tile A2. N2 >= 0.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTTQRT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-N1.
[in]LDWORKThe dimension of the array WORK. LDWORK >= max(1,IB).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 116 of file core_zttmlq.c.

References CORE_zparfb(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, PlasmaRight, and PlasmaRowwise.

{
int i, i1, i3, l;
int NQ, NW;
int kb;
int ic = 0;
int jc = 0;
int mi1 = M1;
int mi2 = M2;
int ni1 = N1;
int ni2 = N2;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/* NQ is the order of Q */
if (side == PlasmaLeft) {
NQ = N2;
NW = IB;
}
else {
NQ = M2;
NW = N1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M1 < 0) {
coreblas_error(3, "Illegal value of M1");
return -3;
}
if (N1 < 0) {
coreblas_error(4, "Illegal value of N1");
return -4;
}
if ((M2 < 0) ||
( (side == PlasmaRight) && (M1 != M2) ) ) {
coreblas_error(5, "Illegal value of M2");
return -5;
}
if ((N2 < 0) ||
( (side == PlasmaLeft) && (N1 != N2) ) ) {
coreblas_error(6, "Illegal value of N2");
return -6;
}
if ((K < 0) ||
( (side == PlasmaLeft) && (K > M1) ) ||
( (side == PlasmaRight) && (K > N1) ) ) {
coreblas_error(7, "Illegal value of K");
return -7;
}
if (IB < 0) {
coreblas_error(8, "Illegal value of IB");
return -8;
}
if (LDA1 < max(1,M1)){
coreblas_error(10, "Illegal value of LDA1");
return -10;
}
if (LDA2 < max(1,M2)){
coreblas_error(12, "Illegal value of LDA2");
return -12;
}
if (LDV < max(1,NQ)){
coreblas_error(14, "Illegal value of LDV");
return -14;
}
if (LDT < max(1,IB)){
coreblas_error(16, "Illegal value of LDT");
return -16;
}
if (LDWORK < max(1,NW)){
coreblas_error(18, "Illegal value of LDWORK");
return -18;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans == PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans != PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ( ( K-1 ) / IB )*IB;
i3 = -IB;
}
/* Transpose */
if (trans == PlasmaNoTrans) {
trans = PlasmaConjTrans;
}
else {
trans = PlasmaNoTrans;
}
for (i = i1; (i > -1) && (i < K); i+=i3) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
mi1 = kb; // M1 - i;
mi2 = min(i+kb, M2);
l = min(kb, max(0, M2-i));
ic = i;
}
else {
ni1 = kb;
ni2 = min(i+kb, N2);
l = min(kb, max(0, N2-i));
jc = i;
}
/*
* Apply H or H' (NOTE: CORE_zparfb used to be CORE_zttrfb)
*/
CORE_zparfb(
side, trans, PlasmaForward, PlasmaRowwise,
mi1, ni1, mi2, ni2, kb, l,
&A1[LDA1*jc+ic], LDA1,
A2, LDA2,
&V[i], LDV,
&T[LDT*i], LDT,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zttmlq_quark ( Quark *  quark)

Definition at line 299 of file core_zttmlq.c.

References CORE_zttmlq(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_zttmlq(side, trans, m1, n1, m2, n2, k, ib, A1, lda1,
A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zttmqr ( int  side,
int  trans,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  V,
int  LDV,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_zttmqr overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 (N1 == N2) with 

                  SIDE = 'L'        SIDE = 'R'

TRANS = 'N': Q * | A1 | | A1 | * Q | A2 | | A2 |

TRANS = 'C': Q**H * | A1 | | A1 | * Q**H | A2 | | A2 |

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_zttqrt.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : ConjTranspose, apply Q**H.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0.
[in]N2The number of columns of the tile A2. N2 >= 0.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_ZTTQRT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]WORKWorkspace array of size LDWORK-by-N1.
[in]LDWORKThe dimension of the array WORK. LDWORK >= max(1,IB).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 116 of file core_zttmqr.c.

References CORE_zparfb(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, and PlasmaRight.

{
int i, i1, i3;
int NQ, NW;
int kb, l;
int ic = 0;
int jc = 0;
int mi1 = M1;
int mi2 = M2;
int ni1 = N1;
int ni2 = N2;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/* NQ is the order of Q */
if (side == PlasmaLeft) {
NQ = M2;
NW = IB;
}
else {
NQ = N2;
NW = M1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M1 < 0) {
coreblas_error(3, "Illegal value of M1");
return -3;
}
if (N1 < 0) {
coreblas_error(4, "Illegal value of N1");
return -4;
}
if ( (M2 < 0) ||
( (M2 != M1) && (side == PlasmaRight) ) ){
coreblas_error(5, "Illegal value of M2");
return -5;
}
if ( (N2 < 0) ||
( (N2 != N1) && (side == PlasmaLeft) ) ){
coreblas_error(6, "Illegal value of N2");
return -6;
}
if ((K < 0) ||
( (side == PlasmaLeft) && (K > M1) ) ||
( (side == PlasmaRight) && (K > N1) ) ) {
coreblas_error(7, "Illegal value of K");
return -7;
}
if (IB < 0) {
coreblas_error(8, "Illegal value of IB");
return -8;
}
if (LDA1 < max(1,M1)){
coreblas_error(10, "Illegal value of LDA1");
return -10;
}
if (LDA2 < max(1,M2)){
coreblas_error(12, "Illegal value of LDA2");
return -12;
}
if (LDV < max(1,NQ)){
coreblas_error(14, "Illegal value of LDV");
return -14;
}
if (LDT < max(1,IB)){
coreblas_error(16, "Illegal value of LDT");
return -16;
}
if (LDWORK < max(1,NW)){
coreblas_error(18, "Illegal value of LDWORK");
return -18;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans != PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans == PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ( ( K-1 ) / IB )*IB;
i3 = -IB;
}
for (i = i1; (i > -1) && (i < K); i+=i3) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
mi1 = kb;
mi2 = min(i+kb, M2);
l = min(kb, max(0, M2-i));
ic = i;
}
else {
ni1 = kb;
ni2 = min(i+kb, N2);
l = min(kb, max(0, N2-i));
jc = i;
}
/*
* Apply H or H' (NOTE: CORE_zparfb used to be CORE_zttrfb)
*/
CORE_zparfb(
side, trans, PlasmaForward, PlasmaColumnwise,
mi1, ni1, mi2, ni2, kb, l,
&A1[LDA1*jc+ic], LDA1,
A2, LDA2,
&V[LDV*i], LDV,
&T[LDT*i], LDT,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zttmqr_quark ( Quark *  quark)

Definition at line 291 of file core_zttmqr.c.

References CORE_zttmqr(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *V;
int ldv;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_zttmqr(side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zttqrt ( int  M,
int  N,
int  IB,
PLASMA_Complex64_t *  A1,
int  LDA1,
PLASMA_Complex64_t *  A2,
int  LDA2,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  TAU,
PLASMA_Complex64_t *  WORK 
)

CORE_zttqrt computes a QR factorization of a rectangular matrix formed by coupling a complex N-by-N upper triangular tile A1 on top of a complex M-by-N upper trapezoidal tile A2:

| A1 | = Q * R | A2 |

The tile Q is represented as a product of elementary reflectors

Q = H(1) H(2) . . . H(k), where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; v(i+1:m) is stored on exit in A2(1:m,i), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A2. M >= 0.
[in]NThe number of columns of the tile A1 and A2. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the N-by-N tile A1. On exit, the elements on and above the diagonal of the array contain the N-by-N upper trapezoidal tile R; the elements below the diagonal are not referenced.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,N).
[in,out]A2On entry, the M-by-N upper triangular tile A2. On exit, the elements on and above the diagonal of the array with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDA2The leading dimension of the array A2. LDA2 >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[in,out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 100 of file core_zttqrt.c.

References CBLAS_SADDR, cblas_zaxpy(), cblas_zcopy(), cblas_zgemv(), cblas_zgerc(), cblas_ztrmv(), CblasColMajor, conj(), CORE_zlaset(), CORE_zparfb(), CORE_zpemv(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, and PlasmaUpperLower.

{
static int ione = 1;
static PLASMA_Complex64_t zone = 1.0;
static PLASMA_Complex64_t zzero = 0.0;
PLASMA_Complex64_t alpha;
int i, j, l, ii, sb, mi, ni;
/* Check input arguments */
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if (IB < 0) {
coreblas_error(3, "Illegal value of IB");
return -3;
}
if ((LDA2 < max(1,M)) && (M > 0)) {
coreblas_error(7, "Illegal value of LDA2");
return -7;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
/* TODO: Need to check why some cases require
* this to not have uninitialized values */
CORE_zlaset( PlasmaUpperLower, IB, N,
0., 0., T, LDT);
for (ii = 0; ii < N; ii += IB) {
sb = min(N-ii, IB);
for (i = 0; i < sb; i++) {
j = ii + i;
mi = min( j + 1, M );
ni = sb-i-1;
/*
* Generate elementary reflector H( II*IB+I ) to annihilate
* A( II*IB+I:mi, II*IB+I ).
*/
LAPACKE_zlarfg_work(
mi+1, &A1[LDA1*j+j], &A2[LDA2*j], ione, &TAU[j]);
if (ni > 0) {
/*
* Apply H( II*IB+I ) to A( II*IB+I:M, II*IB+I+1:II*IB+IB ) from the left.
*/
cblas_zcopy(
ni,
&A1[LDA1*(j+1)+j], LDA1,
WORK, 1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(ni, WORK, 1);
#endif
cblas_zgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaConjTrans,
mi, ni,
CBLAS_SADDR(zone), &A2[LDA2*(j+1)], LDA2,
&A2[LDA2*j], 1,
CBLAS_SADDR(zone), WORK, 1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(ni, WORK, 1);
#endif
alpha = -conj(TAU[j]);
cblas_zaxpy(
ni, CBLAS_SADDR(alpha),
WORK, 1,
&A1[LDA1*(j+1)+j], LDA1);
#ifdef COMPLEX
LAPACKE_zlacgv_work(ni, WORK, 1);
#endif
cblas_zgerc(
CblasColMajor, mi, ni,
CBLAS_SADDR(alpha), &A2[LDA2*j], 1,
WORK, 1,
&A2[LDA2*(j+1)], LDA2);
}
/*
* Calculate T
*
* T(0:i-1, j) = alpha * A2(0:M-1, ii:j-1)' * A2(0:M-1, j)
*/
if ( i > 0 ) {
l = min(i, max(0, M-ii));
alpha = -(TAU[j]);
CORE_zpemv(
PlasmaConjTrans, PlasmaColumnwise,
min(j, M), i, l,
alpha, &A2[LDA2*ii], LDA2,
&A2[LDA2*j], 1,
zzero, &T[LDT*j], 1,
WORK);
/* T(0:i-1, j) = T(0:i-1, ii:j-1) * T(0:i-1, j) */
cblas_ztrmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)PlasmaNoTrans,
(CBLAS_DIAG)PlasmaNonUnit,
i, &T[LDT*ii], LDT,
&T[LDT*j], 1);
}
T[LDT*j+i] = TAU[j];
}
/* Apply Q' to the rest of the matrix to the left */
if (N > ii+sb) {
mi = min(ii+sb, M);
ni = N-(ii+sb);
l = min(sb, max(0, mi-ii));
CORE_zparfb(
PlasmaLeft, PlasmaConjTrans,
PlasmaForward, PlasmaColumnwise,
IB, ni, mi, ni, sb, l, //replaced sb by IB
&A1[LDA1*(ii+sb)+ii], LDA1,
&A2[LDA2*(ii+sb)], LDA2,
&A2[LDA2*ii], LDA2,
&T[LDT*ii], LDT,
WORK, sb);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_zttqrt_quark ( Quark *  quark)

Definition at line 273 of file core_zttqrt.c.

References CORE_zttqrt(), quark_unpack_args_11, T, and TAU.

{
int m;
int n;
int ib;
PLASMA_Complex64_t *A1;
int lda1;
PLASMA_Complex64_t *A2;
int lda2;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *TAU;
PLASMA_Complex64_t *WORK;
quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
CORE_zttqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zunmlq ( int  side,
int  trans,
int  M,
int  N,
int  K,
int  IB,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  C,
int  LDC,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_zunmlq overwrites the general complex M-by-N tile C with 

              SIDE = 'L'     SIDE = 'R'

TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(k) . . . H(2) H(1)

as returned by CORE_zgelqt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : Transpose, apply Q**H.
[in]MThe number of rows of the tile C. M >= 0.
[in]NThe number of columns of the tile C. N >= 0.
[in]KThe number of elementary reflectors whose product defines the matrix Q. If SIDE = PlasmaLeft, M >= K >= 0; if SIDE = PlasmaRight, N >= K >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in]ADimension: (LDA,M) if SIDE = PlasmaLeft, (LDA,N) if SIDE = PlasmaRight, The i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgelqt in the first k rows of its array argument A.
[in]LDAThe leading dimension of the array A. LDA >= max(1,K).
[out]TThe IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[in,out]COn entry, the M-by-N tile C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
[in]LDCThe leading dimension of the array C. LDC >= max(1,M).
[in,out]WORKOn exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
[in]LDWORKThe dimension of the array WORK. If SIDE = PlasmaLeft, LDWORK >= max(1,N); if SIDE = PlasmaRight, LDWORK >= max(1,M).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 108 of file core_zunmlq.c.

References coreblas_error, lapack_const, max, min, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, PlasmaRight, and PlasmaRowwise.

{
int i, kb;
int i1, i3;
int nq, nw;
int ic = 0;
int jc = 0;
int ni = N;
int mi = M;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/*
* NQ is the order of Q and NW is the minimum dimension of WORK
*/
if (side == PlasmaLeft) {
nq = M;
nw = N;
}
else {
nq = N;
nw = M;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M < 0) {
coreblas_error(3, "Illegal value of M");
return -3;
}
if (N < 0) {
coreblas_error(4, "Illegal value of N");
return -4;
}
if ((K < 0) || (K > nq)) {
coreblas_error(5, "Illegal value of K");
return -5;
}
if ((IB < 0) || ( (IB == 0) && ((M > 0) && (N > 0)) )) {
coreblas_error(6, "Illegal value of IB");
return -6;
}
if ((LDA < max(1,K)) && (K > 0)) {
coreblas_error(8, "Illegal value of LDA");
return -8;
}
if ((LDC < max(1,M)) && (M > 0)) {
coreblas_error(12, "Illegal value of LDC");
return -12;
}
if ((LDWORK < max(1,nw)) && (nw > 0)) {
coreblas_error(14, "Illegal value of LDWORK");
return -14;
}
/* Quick return */
if ((M == 0) || (N == 0) || (K == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans == PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans != PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ( ( K-1 ) / IB )*IB;
i3 = -IB;
}
if( trans == PlasmaNoTrans) {
trans = PlasmaConjTrans;
}
else {
trans = PlasmaNoTrans;
}
for(i = i1; (i >- 1) && (i < K); i+=i3 ) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
/*
* H or H' is applied to C(i:m,1:n)
*/
mi = M - i;
ic = i;
}
else {
/*
* H or H' is applied to C(1:m,i:n)
*/
ni = N - i;
jc = i;
}
/*
* Apply H or H'
*/
LAPACKE_zlarfb_work(LAPACK_COL_MAJOR,
lapack_const(side),
lapack_const(trans),
lapack_const(PlasmaForward),
lapack_const(PlasmaRowwise),
mi, ni, kb,
&A[LDA*i+i], LDA,
&T[LDT*i], LDT,
&C[LDC*jc+ic], LDC,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the caller graph for this function:

void CORE_zunmlq_quark ( Quark *  quark)

Definition at line 264 of file core_zunmlq.c.

References A, C, CORE_zunmlq(), quark_unpack_args_14, side, T, and trans.

{
int side;
int trans;
int m;
int n;
int k;
int ib;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *C;
int ldc;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_14(quark, side, trans, m, n, k, ib,
A, lda, T, ldt, C, ldc, WORK, ldwork);
CORE_zunmlq(side, trans, m, n, k, ib,
A, lda, T, ldt, C, ldc, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int CORE_zunmqr ( int  side,
int  trans,
int  M,
int  N,
int  K,
int  IB,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  T,
int  LDT,
PLASMA_Complex64_t *  C,
int  LDC,
PLASMA_Complex64_t *  WORK,
int  LDWORK 
)

CORE_zunmqr overwrites the general complex M-by-N tile C with 

              SIDE = 'L'     SIDE = 'R'

TRANS = 'N': Q * C C * Q TRANS = 'C': Q**H * C C * Q**H

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_zgeqrt. Q is of order M if SIDE = 'L' and of order N if SIDE = 'R'.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**H from the Left;
  • PlasmaRight : apply Q or Q**H from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaConjTrans : Transpose, apply Q**H.
[in]MThe number of rows of the tile C. M >= 0.
[in]NThe number of columns of the tile C. N >= 0.
[in]KThe number of elementary reflectors whose product defines the matrix Q. If SIDE = PlasmaLeft, M >= K >= 0; if SIDE = PlasmaRight, N >= K >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in]ADimension: (LDA,K) The i-th column must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_zgeqrt in the first k columns of its array argument A.
[in]LDAThe leading dimension of the array A. If SIDE = PlasmaLeft, LDA >= max(1,M); if SIDE = PlasmaRight, LDA >= max(1,N).
[out]TThe IB-by-K triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[in,out]COn entry, the M-by-N tile C. On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
[in]LDCThe leading dimension of the array C. LDC >= max(1,M).
[in,out]WORKOn exit, if INFO = 0, WORK(1) returns the optimal LDWORK.
[in]LDWORKThe dimension of the array WORK. If SIDE = PlasmaLeft, LDWORK >= max(1,N); if SIDE = PlasmaRight, LDWORK >= max(1,M).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 108 of file core_zunmqr.c.

References coreblas_error, lapack_const, max, min, PLASMA_SUCCESS, PlasmaColumnwise, PlasmaConjTrans, PlasmaForward, PlasmaLeft, PlasmaNoTrans, and PlasmaRight.

{
int i, kb;
int i1, i3;
int nq, nw;
int ic = 0;
int jc = 0;
int ni = N;
int mi = M;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/*
* NQ is the order of Q and NW is the minimum dimension of WORK
*/
if (side == PlasmaLeft) {
nq = M;
nw = N;
}
else {
nq = N;
nw = M;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaConjTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M < 0) {
coreblas_error(3, "Illegal value of M");
return -3;
}
if (N < 0) {
coreblas_error(4, "Illegal value of N");
return -4;
}
if ((K < 0) || (K > nq)) {
coreblas_error(5, "Illegal value of K");
return -5;
}
if ((IB < 0) || ( (IB == 0) && ((M > 0) && (N > 0)) )) {
coreblas_error(6, "Illegal value of IB");
return -6;
}
if ((LDA < max(1,nq)) && (nq > 0)) {
coreblas_error(8, "Illegal value of LDA");
return -8;
}
if ((LDC < max(1,M)) && (M > 0)) {
coreblas_error(12, "Illegal value of LDC");
return -12;
}
if ((LDWORK < max(1,nw)) && (nw > 0)) {
coreblas_error(14, "Illegal value of LDWORK");
return -14;
}
/* Quick return */
if ((M == 0) || (N == 0) || (K == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans != PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans == PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ( ( K-1 ) / IB )*IB;
i3 = -IB;
}
for(i = i1; (i >- 1) && (i < K); i+=i3 ) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
/*
* H or H' is applied to C(i:m,1:n)
*/
mi = M - i;
ic = i;
}
else {
/*
* H or H' is applied to C(1:m,i:n)
*/
ni = N - i;
jc = i;
}
/*
* Apply H or H'
*/
LAPACKE_zlarfb_work(LAPACK_COL_MAJOR,
lapack_const(side),
lapack_const(trans),
lapack_const(PlasmaForward),
lapack_const(PlasmaColumnwise),
mi, ni, kb,
&A[LDA*i+i], LDA,
&T[LDT*i], LDT,
&C[LDC*jc+ic], LDC,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the caller graph for this function:

void CORE_zunmqr_quark ( Quark *  quark)

Definition at line 257 of file core_zunmqr.c.

References A, C, CORE_zunmqr(), quark_unpack_args_14, side, T, and trans.

{
int side;
int trans;
int m;
int n;
int k;
int ib;
PLASMA_Complex64_t *A;
int lda;
PLASMA_Complex64_t *T;
int ldt;
PLASMA_Complex64_t *C;
int ldc;
PLASMA_Complex64_t *WORK;
int ldwork;
quark_unpack_args_14(quark, side, trans, m, n, k, ib,
A, lda, T, ldt, C, ldc, WORK, ldwork);
CORE_zunmqr(side, trans, m, n, k, ib,
A, lda, T, ldt, C, ldc, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_dzasum ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  storev,
PLASMA_enum  uplo,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  szeA,
double *  work,
int  szeW 
)
Declarations of QUARK wrappers (called by PLASMA) - alphabetical order

Definition at line 95 of file core_dzasum.c.

References CORE_dzasum_quark(), INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(
quark, CORE_dzasum_quark, task_flags,
sizeof(PLASMA_enum), &storev, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(double)*szeW, work, INOUT,
0);
}

Here is the call graph for this function:

void QUARK_CORE_dzasum_f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  storev,
PLASMA_enum  uplo,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  szeA,
double *  work,
int  szeW,
double *  fake,
int  szeF 
)

Definition at line 136 of file core_dzasum.c.

References CORE_dzasum_f1_quark(), DAG_CORE_ASUM, GATHERV, INOUT, INPUT, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_ASUM;
QUARK_Insert_Task(
quark, CORE_dzasum_f1_quark, task_flags,
sizeof(PLASMA_enum), &storev, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(double)*szeW, work, INOUT,
sizeof(double)*szeF, fake, OUTPUT | GATHERV,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zbrdalg ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  N,
int  NB,
PLASMA_desc *  A,
PLASMA_Complex64_t *  C,
PLASMA_Complex64_t *  S,
int  i,
int  j,
int  m,
int  grsiz,
int  BAND,
int *  PCOL,
int *  ACOL,
int *  MCOL 
)

Definition at line 127 of file core_zbrdalg.c.

References CORE_zbrdalg_quark(), INPUT, LOCALITY, NODEP, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(quark, CORE_zbrdalg_quark, task_flags,
sizeof(int), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(int), &NB, VALUE,
sizeof(PLASMA_desc), A, NODEP,
sizeof(PLASMA_Complex64_t), V, NODEP,
sizeof(PLASMA_Complex64_t), TAU, NODEP,
sizeof(int), &i, VALUE,
sizeof(int), &j, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &grsiz, VALUE,
sizeof(int), PCOL, INPUT,
sizeof(int), ACOL, INPUT,
sizeof(int), MCOL, OUTPUT | LOCALITY,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgeadd ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  B,
int  ldb 
)

Definition at line 43 of file core_zgeadd.c.

References CORE_zgeadd_quark(), DAG_CORE_GEADD, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEADD;
QUARK_Insert_Task(quark, CORE_zgeadd_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INOUT,
sizeof(int), &ldb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgelqt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 154 of file core_zgelqt.c.

References CORE_zgelqt_quark(), DAG_CORE_GELQT, INOUT, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_GELQT;
QUARK_Insert_Task(quark, CORE_zgelqt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgemm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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 
)

Definition at line 46 of file core_zgemm.c.

References CORE_zgemm_quark(), DAG_CORE_GEMM, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgemm2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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 
)

Definition at line 74 of file core_zgemm.c.

References CORE_zgemm_quark(), DAG_CORE_GEMM, GATHERV, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT | LOCALITY | GATHERV,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgemm_f2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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,
PLASMA_Complex64_t *  fake1,
int  szefake1,
int  flag1,
PLASMA_Complex64_t *  fake2,
int  szefake2,
int  flag2 
)

Definition at line 135 of file core_zgemm.c.

References CORE_zgemm_f2_quark(), DAG_CORE_GEMM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_f2_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT | LOCALITY,
sizeof(int), &ldc, VALUE,
sizeof(PLASMA_Complex64_t)*szefake1, fake1, flag1,
sizeof(PLASMA_Complex64_t)*szefake2, fake2, flag2,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgemm_p2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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 
)

Definition at line 202 of file core_zgemm.c.

References CORE_zgemm_p2_quark(), DAG_CORE_GEMM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_p2_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*lda*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t*), B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*ldc*nb, C, INOUT | LOCALITY,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zgemm_p2f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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,
PLASMA_Complex64_t *  fake1,
int  szefake1,
int  flag1 
)

Definition at line 326 of file core_zgemm.c.

References CORE_zgemm_p2f1_quark(), DAG_CORE_GEMM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_p2f1_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*lda*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t*), B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*ldc*nb, C, INOUT | LOCALITY,
sizeof(int), &ldc, VALUE,
sizeof(PLASMA_Complex64_t)*szefake1, fake1, flag1,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zgemm_p3 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  transA,
int  transB,
int  m,
int  n,
int  k,
int  nb,
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 
)

Definition at line 264 of file core_zgemm.c.

References CORE_zgemm_p3_quark(), DAG_CORE_GEMM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GEMM;
QUARK_Insert_Task(quark, CORE_zgemm_p3_quark, task_flags,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &transB, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*lda*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ldb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t*), C, INOUT | LOCALITY,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zgeqrt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 155 of file core_zgeqrt.c.

References CORE_zgeqrt_quark(), DAG_CORE_GEQRT, INOUT, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_GEQRT;
QUARK_Insert_Task(quark, CORE_zgeqrt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgessm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  k,
int  ib,
int  nb,
int *  IPIV,
PLASMA_Complex64_t *  L,
int  ldl,
PLASMA_Complex64_t *  A,
int  lda 
)

Definition at line 145 of file core_zgessm.c.

References CORE_zgessm_quark(), DAG_CORE_GESSM, INOUT, INPUT, QUARK_Insert_Task(), QUARK_REGION_L, and VALUE.

{
DAG_CORE_GESSM;
QUARK_Insert_Task(quark, CORE_zgessm_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(int)*nb, IPIV, INPUT,
sizeof(PLASMA_Complex64_t)*nb*nb, L, INPUT | QUARK_REGION_L,
sizeof(int), &ldl, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrf ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
int *  IPIV,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
PLASMA_bool  check_info,
int  iinfo 
)

Definition at line 33 of file core_zgetrf.c.

References CORE_zgetrf_quark(), DAG_CORE_GETRF, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GETRF;
QUARK_Insert_Task(quark, CORE_zgetrf_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT | LOCALITY,
sizeof(int), &lda, VALUE,
sizeof(int)*nb, IPIV, OUTPUT,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(PLASMA_bool), &check_info, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrf_incpiv ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
int *  IPIV,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
PLASMA_bool  check_info,
int  iinfo 
)

Definition at line 145 of file core_zgetrf_incpiv.c.

References CORE_zgetrf_incpiv_quark(), DAG_CORE_GETRF, INOUT, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GETRF;
QUARK_Insert_Task(quark, CORE_zgetrf_incpiv_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(int)*nb, IPIV, OUTPUT,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(PLASMA_bool), &check_info, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrf_reclap ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
int *  IPIV,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
PLASMA_bool  check_info,
int  iinfo,
int  nbthread 
)

Definition at line 351 of file core_zgetrf_reclap.c.

References CORE_zgetrf_reclap_quark(), DAG_CORE_GETRF, INOUT, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GETRF;
QUARK_Insert_Task(quark, CORE_zgetrf_reclap_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(int)*nb, IPIV, OUTPUT,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(PLASMA_bool), &check_info, VALUE,
sizeof(int), &iinfo, VALUE,
sizeof(int), &nbthread, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrf_rectil ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_desc  A,
PLASMA_Complex64_t *  Amn,
int  size,
int *  IPIV,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
PLASMA_bool  check_info,
int  iinfo,
int  nbthread 
)

Definition at line 699 of file core_zgetrf_rectil.c.

References CORE_zgetrf_rectil_quark(), DAG_CORE_GETRF, INOUT, plasma_desc_t::n, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_GETRF;
QUARK_Insert_Task(quark, CORE_zgetrf_rectil_quark, task_flags,
sizeof(PLASMA_desc), &A, VALUE,
sizeof(PLASMA_Complex64_t)*size, Amn, INOUT,
sizeof(int)*A.n, IPIV, OUTPUT,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(PLASMA_bool), &check_info, VALUE,
sizeof(int), &iinfo, VALUE,
sizeof(int), &nbthread, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrip ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  szeA 
)

Definition at line 82 of file core_zgetrip.c.

References CORE_zgetrip_quark(), DAG_CORE_GETRIP, INOUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_GETRIP;
QUARK_Insert_Task(quark, CORE_zgetrip_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INOUT,
sizeof(PLASMA_Complex64_t)*szeA, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrip_f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  szeA,
PLASMA_Complex64_t *  fake,
int  szeF,
int  paramF 
)

Definition at line 115 of file core_zgetrip.c.

References CORE_zgetrip_f1_quark(), DAG_CORE_GETRIP, INOUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_GETRIP;
QUARK_Insert_Task(
quark, CORE_zgetrip_f1_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INOUT,
sizeof(PLASMA_Complex64_t)*szeA, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*szeF, fake, paramF,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zgetrip_f2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  szeA,
PLASMA_Complex64_t *  fake1,
int  szeF1,
int  paramF1,
PLASMA_Complex64_t *  fake2,
int  szeF2,
int  paramF2 
)

Definition at line 153 of file core_zgetrip.c.

References CORE_zgetrip_f2_quark(), DAG_CORE_GETRIP, INOUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_GETRIP;
QUARK_Insert_Task(
quark, CORE_zgetrip_f2_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INOUT,
sizeof(PLASMA_Complex64_t)*szeA, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*szeF1, fake1, paramF1,
sizeof(PLASMA_Complex64_t)*szeF2, fake2, paramF2,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zhegst ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  itype,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
PLASMA_Complex64_t *  B,
int  LDB,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
int  iinfo 
)

Definition at line 39 of file core_zhegst.c.

References CORE_zhegst_quark(), INOUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(quark, CORE_zhegst_quark, task_flags,
sizeof(int), &itype, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*n*n, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*n*n, B, INOUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zhemm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  uplo,
int  m,
int  n,
int  nb,
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 
)

Definition at line 49 of file core_zhemm.c.

References CORE_zhemm_quark(), DAG_CORE_HEMM, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_HEMM;
QUARK_Insert_Task(quark, CORE_zhemm_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zher2k ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  trans,
int  n,
int  k,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  B,
int  LDB,
double  beta,
PLASMA_Complex64_t *  C,
int  ldc 
)

Definition at line 48 of file core_zher2k.c.

References CORE_zher2k_quark(), DAG_CORE_HER2K, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_HER2K;
QUARK_Insert_Task(quark, CORE_zher2k_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(double), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zherfb ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  uplo,
int  n,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  C,
int  ldc 
)

This kernel is just a workaround for now... will be deleted eventually and replaced by the one above (Piotr's Task)

Definition at line 183 of file core_zherfb.c.

References CORE_zherfb_quark(), INOUT, INPUT, PlasmaUpper, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, QUARK_REGION_U, SCRATCH, and VALUE.

{
QUARK_Insert_Task(
quark, CORE_zherfb_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(int), &nb, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, uplo == PlasmaUpper ? INOUT|QUARK_REGION_U : INOUT|QUARK_REGION_L,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, uplo == PlasmaUpper ? INOUT|QUARK_REGION_D|QUARK_REGION_U : INOUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &ldc, VALUE,
sizeof(PLASMA_Complex64_t)*2*nb*nb, NULL, SCRATCH,
sizeof(int), &nb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zherk ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  trans,
int  n,
int  k,
int  nb,
double  alpha,
PLASMA_Complex64_t *  A,
int  lda,
double  beta,
PLASMA_Complex64_t *  C,
int  ldc 
)

Definition at line 47 of file core_zherk.c.

References CORE_zherk_quark(), DAG_CORE_HERK, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_HERK;
QUARK_Insert_Task(quark, CORE_zherk_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(double), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(double), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlacpy ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  uplo,
int  m,
int  n,
int  mb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  B,
int  ldb 
)

Definition at line 42 of file core_zlacpy.c.

References CORE_zlacpy_quark(), DAG_CORE_LACPY, INPUT, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LACPY;
QUARK_Insert_Task(quark, CORE_zlacpy_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, OUTPUT,
sizeof(int), &ldb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlange ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  M,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result 
)

Definition at line 42 of file core_zlange.c.

References CORE_zlange_quark(), DAG_CORE_LANGE, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANGE;
QUARK_Insert_Task(quark, CORE_zlange_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zlange_f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  M,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result,
double *  fake,
int  szeF 
)

Definition at line 87 of file core_zlange.c.

References CORE_zlange_f1_quark(), DAG_CORE_LANGE, GATHERV, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANGE;
QUARK_Insert_Task(quark, CORE_zlange_f1_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
sizeof(double)*szeF, fake, OUTPUT | GATHERV,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlanhe ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result 
)

Definition at line 42 of file core_zlanhe.c.

References CORE_zlanhe_quark(), DAG_CORE_LANHE, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANHE;
QUARK_Insert_Task(quark, CORE_zlanhe_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zlanhe_f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result,
double *  fake,
int  szeF 
)

Definition at line 87 of file core_zlanhe.c.

References CORE_zlanhe_f1_quark(), DAG_CORE_LANHE, GATHERV, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANHE;
QUARK_Insert_Task(quark, CORE_zlanhe_f1_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
sizeof(double)*szeF, fake, OUTPUT | GATHERV,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlansy ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result 
)

Definition at line 42 of file core_zlansy.c.

References CORE_zlansy_quark(), DAG_CORE_LANSY, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANSY;
QUARK_Insert_Task(quark, CORE_zlansy_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zlansy_f1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  norm,
int  uplo,
int  N,
PLASMA_Complex64_t *  A,
int  LDA,
int  szeA,
int  szeW,
double *  result,
double *  fake,
int  szeF 
)

Definition at line 87 of file core_zlansy.c.

References CORE_zlansy_f1_quark(), DAG_CORE_LANSY, GATHERV, INPUT, max, OUTPUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
szeW = max(1, szeW);
DAG_CORE_LANSY;
QUARK_Insert_Task(quark, CORE_zlansy_f1_quark, task_flags,
sizeof(PLASMA_enum), &norm, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INPUT,
sizeof(int), &LDA, VALUE,
sizeof(double)*szeW, NULL, SCRATCH,
sizeof(double), result, OUTPUT,
sizeof(double)*szeF, fake, OUTPUT | GATHERV,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaset ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  uplo,
int  n1,
int  n2,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t  beta,
PLASMA_Complex64_t *  tileA,
int  ldtilea 
)

Definition at line 71 of file core_zlaset.c.

References CORE_zlaset_quark(), DAG_CORE_LASET, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASET;
QUARK_Insert_Task(quark, CORE_zlaset_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*M*N, A, OUTPUT,
sizeof(int), &LDA, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaset2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_enum  uplo,
int  n1,
int  n2,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  tileA,
int  ldtilea 
)

Definition at line 82 of file core_zlaset2.c.

References CORE_zlaset2_quark(), OUTPUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(quark, CORE_zlaset2_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &M, VALUE,
sizeof(int), &N, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*M*N, A, OUTPUT,
sizeof(int), &LDA, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaswp ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  i1,
int  i2,
int *  ipiv,
int  inc 
)

Definition at line 37 of file core_zlaswp.c.

References CORE_zlaswp_quark(), DAG_CORE_LASWP, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASWP;
QUARK_Insert_Task(
quark, CORE_zlaswp_quark, task_flags,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*lda*n, A, INOUT | LOCALITY,
sizeof(int), &lda, VALUE,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*n, ipiv, INPUT,
sizeof(int), &inc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaswp_f2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  fake1,
int  szefake1,
int  flag1,
PLASMA_Complex64_t *  fake2,
int  szefake2,
int  flag2 
)

Definition at line 74 of file core_zlaswp.c.

References CORE_zlaswp_f2_quark(), DAG_CORE_LASWP, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASWP;
QUARK_Insert_Task(
quark, CORE_zlaswp_f2_quark, task_flags,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*lda*n, A, INOUT | LOCALITY,
sizeof(int), &lda, VALUE,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*n, ipiv, INPUT,
sizeof(int), &inc, VALUE,
sizeof(PLASMA_Complex64_t)*szefake1, fake1, flag1,
sizeof(PLASMA_Complex64_t)*szefake2, fake2, flag2,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaswp_ontile ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_desc  descA,
PLASMA_Complex64_t *  A,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  fakepanel 
)

Definition at line 214 of file core_zlaswp.c.

References CORE_zlaswp_ontile_quark(), DAG_CORE_LASWP, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASWP;
QUARK_Insert_Task(
quark, CORE_zlaswp_ontile_quark, task_flags,
sizeof(PLASMA_desc), &descA, VALUE,
sizeof(PLASMA_Complex64_t)*1, Aij, INOUT | LOCALITY,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*(i2-i1+1)*abs(inc), ipiv, INPUT,
sizeof(int), &inc, VALUE,
sizeof(PLASMA_Complex64_t)*1, fakepanel, INOUT,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaswp_ontile_f2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_desc  descA,
PLASMA_Complex64_t *  A,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  fake1,
int  szefake1,
int  flag1,
PLASMA_Complex64_t *  fake2,
int  szefake2,
int  flag2 
)

Definition at line 252 of file core_zlaswp.c.

References CORE_zlaswp_ontile_f2_quark(), DAG_CORE_LASWP, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASWP;
QUARK_Insert_Task(
quark, CORE_zlaswp_ontile_f2_quark, task_flags,
sizeof(PLASMA_desc), &descA, VALUE,
sizeof(PLASMA_Complex64_t)*1, Aij, INOUT | LOCALITY,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*(i2-i1+1)*abs(inc), ipiv, INPUT,
sizeof(int), &inc, VALUE,
sizeof(PLASMA_Complex64_t)*szefake1, fake1, flag1,
sizeof(PLASMA_Complex64_t)*szefake2, fake2, flag2,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlaswpc_ontile ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_desc  descA,
PLASMA_Complex64_t *  A,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  fakepanel 
)

Definition at line 492 of file core_zlaswp.c.

References CORE_zlaswpc_ontile_quark(), DAG_CORE_LASWP, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LASWP;
QUARK_Insert_Task(
quark, CORE_zlaswpc_ontile_quark, task_flags,
sizeof(PLASMA_desc), &descA, VALUE,
sizeof(PLASMA_Complex64_t)*1, Aij, INOUT | LOCALITY,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*(i2-i1+1)*abs(inc), ipiv, INPUT,
sizeof(int), &inc, VALUE,
sizeof(PLASMA_Complex64_t)*1, fakepanel, INOUT,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zlauum ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  n,
int  nb,
PLASMA_Complex64_t *  A,
int  lda 
)

Definition at line 37 of file core_zlauum.c.

References CORE_zlauum_quark(), DAG_CORE_LAUUM, INOUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_LAUUM;
QUARK_Insert_Task(quark, CORE_zlauum_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zpamm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  op,
int  side,
int  storev,
int  m,
int  n,
int  k,
int  l,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  W,
int  ldw 
)

Definition at line 569 of file core_zpamm.c.

References CORE_zpamm_quark(), INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(quark, CORE_zpamm_quark, task_flags,
sizeof(int), &op, VALUE,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &storev, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &l, VALUE,
sizeof(PLASMA_Complex64_t)*m*k, A1, INPUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*k*n, A2, INPUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*m*n, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*m*n, W, INOUT,
sizeof(int), &ldw, VALUE,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zplghe ( Quark *  quark,
Quark_Task_Flags *  task_flags,
double  bump,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 151 of file core_zplghe.c.

References CORE_zplghe_quark(), DAG_CORE_PLGHE, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_PLGHE;
QUARK_Insert_Task(quark, CORE_zplghe_quark, task_flags,
sizeof(double), &bump, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*lda*n, A, OUTPUT,
sizeof(int), &lda, VALUE,
sizeof(int), &bigM, VALUE,
sizeof(int), &m0, VALUE,
sizeof(int), &n0, VALUE,
sizeof(unsigned long long int), &seed, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zplgsy ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_Complex64_t  bump,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 147 of file core_zplgsy.c.

References CORE_zplgsy_quark(), DAG_CORE_PLGSY, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_PLGSY;
QUARK_Insert_Task(quark, CORE_zplgsy_quark, task_flags,
sizeof(PLASMA_Complex64_t), &bump, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*lda*n, A, OUTPUT,
sizeof(int), &lda, VALUE,
sizeof(int), &bigM, VALUE,
sizeof(int), &m0, VALUE,
sizeof(int), &n0, VALUE,
sizeof(unsigned long long int), &seed, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zplrnt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
PLASMA_Complex64_t *  A,
int  lda,
int  bigM,
int  m0,
int  n0,
unsigned long long int  seed 
)

Definition at line 92 of file core_zplrnt.c.

References CORE_zplrnt_quark(), DAG_CORE_PLRNT, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_PLRNT;
QUARK_Insert_Task(quark, CORE_zplrnt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*lda*n, A, OUTPUT,
sizeof(int), &lda, VALUE,
sizeof(int), &bigM, VALUE,
sizeof(int), &m0, VALUE,
sizeof(int), &n0, VALUE,
sizeof(unsigned long long int), &seed, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zpotrf ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  n,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
int  iinfo 
)

Definition at line 40 of file core_zpotrf.c.

References CORE_zpotrf_quark(), DAG_CORE_POTRF, INOUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_POTRF;
QUARK_Insert_Task(quark, CORE_zpotrf_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zshift ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  s,
int  m,
int  n,
int  L,
PLASMA_Complex64_t *  A 
)

Definition at line 187 of file core_zshift.c.

References CORE_zshift_quark(), DAG_CORE_SHIFT, GATHERV, INOUT, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_SHIFT;
QUARK_Insert_Task(quark, CORE_zshift_quark, task_flags,
sizeof(int), &s, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &L, VALUE,
sizeof(PLASMA_Complex64_t)*m*n*L, A, INOUT | GATHERV,
sizeof(PLASMA_Complex64_t)*L, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zshiftw ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  s,
int  cl,
int  m,
int  n,
int  L,
PLASMA_Complex64_t *  A,
PLASMA_Complex64_t *  W 
)

Definition at line 108 of file core_zshift.c.

References CORE_zshiftw_quark(), DAG_CORE_SHIFTW, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_SHIFTW;
QUARK_Insert_Task(quark, CORE_zshiftw_quark, task_flags,
sizeof(int), &s, VALUE,
sizeof(int), &cl, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &L, VALUE,
sizeof(PLASMA_Complex64_t)*m*n*L, A, INOUT,
sizeof(PLASMA_Complex64_t)*L, W, INPUT,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zssssm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  L1,
int  ldl1,
PLASMA_Complex64_t *  L2,
int  ldl2,
int *  IPIV 
)

Definition at line 184 of file core_zssssm.c.

References CORE_zssssm_quark(), DAG_CORE_SSSSM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_SSSSM;
QUARK_Insert_Task(quark, CORE_zssssm_quark, task_flags,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT | LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, L1, INPUT,
sizeof(int), &ldl1, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, L2, INPUT,
sizeof(int), &ldl2, VALUE,
sizeof(int)*nb, IPIV, INPUT,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zswpab ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  i,
int  n1,
int  n2,
PLASMA_Complex64_t *  A,
int  szeA 
)

Definition at line 85 of file core_zswpab.c.

References CORE_zswpab_quark(), DAG_CORE_SWPAB, INOUT, min, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
DAG_CORE_SWPAB;
QUARK_Insert_Task(
quark, CORE_zswpab_quark, task_flags,
sizeof(int), &i, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &n2, VALUE,
sizeof(PLASMA_Complex64_t)*szeA, A, INOUT,
sizeof(PLASMA_Complex64_t)*min(n1,n2), NULL, SCRATCH,
0);
}

Here is the call graph for this function:

void QUARK_CORE_zswptr_ontile ( Quark *  quark,
Quark_Task_Flags *  task_flags,
PLASMA_desc  descA,
PLASMA_Complex64_t *  Aij,
int  i1,
int  i2,
int *  ipiv,
int  inc,
PLASMA_Complex64_t *  Akk,
int  ldak 
)

Definition at line 359 of file core_zlaswp.c.

References CORE_zswptr_ontile_quark(), DAG_CORE_TRSM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_TRSM;
QUARK_Insert_Task(
quark, CORE_zswptr_ontile_quark, task_flags,
sizeof(PLASMA_desc), &descA, VALUE,
sizeof(PLASMA_Complex64_t)*1, Aij, INOUT | LOCALITY,
sizeof(int), &i1, VALUE,
sizeof(int), &i2, VALUE,
sizeof(int)*(i2-i1+1)*abs(inc), ipiv, INPUT,
sizeof(int), &inc, VALUE,
sizeof(PLASMA_Complex64_t)*ldak, Akk, INPUT,
sizeof(int), &ldak, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zsymm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  uplo,
int  m,
int  n,
int  nb,
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 
)

Definition at line 46 of file core_zsymm.c.

References CORE_zsymm_quark(), DAG_CORE_SYMM, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_SYMM;
QUARK_Insert_Task(quark, CORE_zsymm_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zsyr2k ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  trans,
int  n,
int  k,
int  nb,
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 
)

Definition at line 45 of file core_zsyr2k.c.

References CORE_zsyr2k_quark(), DAG_CORE_SYR2K, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_SYR2K;
QUARK_Insert_Task(quark, CORE_zsyr2k_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zsyrk ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  trans,
int  n,
int  k,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t  beta,
PLASMA_Complex64_t *  C,
int  ldc 
)

Definition at line 44 of file core_zsyrk.c.

References CORE_zsyrk_quark(), DAG_CORE_SYRK, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_SYRK;
QUARK_Insert_Task(quark, CORE_zsyrk_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t), &beta, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztrdalg ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  N,
int  NB,
PLASMA_desc *  A,
PLASMA_Complex64_t *  C,
PLASMA_Complex64_t *  S,
int  i,
int  j,
int  m,
int  grsiz,
int  BAND,
int *  PCOL,
int *  ACOL,
int *  MCOL 
)

Definition at line 126 of file core_ztrdalg.c.

References CORE_ztrdalg_quark(), INPUT, LOCALITY, NODEP, OUTPUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(quark, CORE_ztrdalg_quark, task_flags,
sizeof(int), &uplo, VALUE,
sizeof(int), &N, VALUE,
sizeof(int), &NB, VALUE,
sizeof(PLASMA_desc), A, NODEP,
sizeof(PLASMA_Complex64_t), V, NODEP,
sizeof(PLASMA_Complex64_t), TAU, NODEP,
sizeof(int), &i, VALUE,
sizeof(int), &j, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &grsiz, VALUE,
sizeof(int), PCOL, INPUT,
sizeof(int), ACOL, INPUT,
sizeof(int), MCOL, OUTPUT | LOCALITY,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztrmm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  uplo,
int  transA,
int  diag,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  B,
int  ldb 
)

Definition at line 47 of file core_ztrmm.c.

References CORE_ztrmm_quark(), DAG_CORE_TRMM, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_TRMM;
QUARK_Insert_Task(quark, CORE_ztrmm_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &diag, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INOUT,
sizeof(int), &ldb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztrmm_p2 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  uplo,
int  transA,
int  diag,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t **  B,
int  ldb 
)

Definition at line 103 of file core_ztrmm.c.

References CORE_ztrmm_p2_quark(), DAG_CORE_TRMM, INOUT, INPUT, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_TRMM;
QUARK_Insert_Task(quark, CORE_ztrmm_p2_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &diag, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*lda*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t*), B, INOUT,
sizeof(int), &ldb, VALUE,
0);
}

Here is the call graph for this function:

void QUARK_CORE_ztrsm ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  uplo,
int  transA,
int  diag,
int  m,
int  n,
int  nb,
PLASMA_Complex64_t  alpha,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  B,
int  ldb 
)

Definition at line 46 of file core_ztrsm.c.

References CORE_ztrsm_quark(), DAG_CORE_TRSM, INOUT, INPUT, LOCALITY, QUARK_Insert_Task(), and VALUE.

{
DAG_CORE_TRSM;
QUARK_Insert_Task(quark, CORE_ztrsm_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &transA, VALUE,
sizeof(PLASMA_enum), &diag, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t), &alpha, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, B, INOUT | LOCALITY,
sizeof(int), &ldb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztrtri ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  uplo,
int  diag,
int  n,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
int  iinfo 
)

Definition at line 40 of file core_ztrtri.c.

References CORE_ztrtri_quark(), INOUT, QUARK_Insert_Task(), and VALUE.

{
QUARK_Insert_Task(
quark, CORE_ztrtri_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &diag, VALUE,
sizeof(int), &n, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztslqt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 218 of file core_ztslqt.c.

References CORE_ztslqt_quark(), DAG_CORE_TSLQT, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
DAG_CORE_TSLQT;
QUARK_Insert_Task(quark, CORE_ztslqt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT | QUARK_REGION_D | QUARK_REGION_L,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT | LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmlq ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 263 of file core_ztsmlq.c.

References CORE_ztsmlq_quark(), DAG_CORE_TSMLQ, INOUT, INPUT, LOCALITY, PlasmaLeft, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
DAG_CORE_TSMLQ;
QUARK_Insert_Task(quark, CORE_ztsmlq_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT | LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmlq_corner ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m1,
int  n1,
int  m2,
int  n2,
int  m3,
int  n3,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  A3,
int  lda3,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 219 of file core_ztsmlq_corner.c.

References CORE_ztsmlq_corner_quark(), INOUT, INPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
int ldwork = nb;
QUARK_Insert_Task(quark, CORE_ztsmlq_corner_quark, task_flags,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &m3, VALUE,
sizeof(int), &n3, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(int), &nb, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_D|QUARK_REGION_U,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A3, INOUT|QUARK_REGION_D|QUARK_REGION_U,
sizeof(int), &lda3, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*4*nb*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmlq_hetra1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 174 of file core_ztsmlq_hetra1.c.

References CORE_ztsmlq_hetra1_quark(), INOUT, INPUT, PlasmaLeft, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
QUARK_Insert_Task(quark, CORE_ztsmlq_hetra1_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_U|QUARK_REGION_D,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmqr ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 258 of file core_ztsmqr.c.

References CORE_ztsmqr_quark(), DAG_CORE_TSMQR, INOUT, INPUT, LOCALITY, PlasmaLeft, QUARK_Insert_Task(), SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
DAG_CORE_TSMQR;
QUARK_Insert_Task(quark, CORE_ztsmqr_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT | LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmqr_corner ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m1,
int  n1,
int  m2,
int  n2,
int  m3,
int  n3,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  A3,
int  lda3,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 214 of file core_ztsmqr_corner.c.

References CORE_ztsmqr_corner_quark(), INOUT, INPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
int ldwork = nb;
QUARK_Insert_Task(quark, CORE_ztsmqr_corner_quark, task_flags,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &m3, VALUE,
sizeof(int), &n3, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(int), &nb, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A3, INOUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &lda3, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*4*nb*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsmqr_hetra1 ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 173 of file core_ztsmqr_hetra1.c.

References CORE_ztsmqr_hetra1_quark(), INOUT, INPUT, PlasmaLeft, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
QUARK_Insert_Task(quark, CORE_ztsmqr_hetra1_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_L|QUARK_REGION_D,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztsqrt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 209 of file core_ztsqrt.c.

References CORE_ztsqrt_quark(), DAG_CORE_TSQRT, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
DAG_CORE_TSQRT;
QUARK_Insert_Task(quark, CORE_ztsqrt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT | QUARK_REGION_D | QUARK_REGION_U,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT | LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_ztstrf ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  U,
int  ldu,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  L,
int  ldl,
int *  IPIV,
PLASMA_sequence *  sequence,
PLASMA_request *  request,
PLASMA_bool  check_info,
int  iinfo 
)

Definition at line 220 of file core_ztstrf.c.

References CORE_ztstrf_quark(), DAG_CORE_TSTRF, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
DAG_CORE_TSTRF;
QUARK_Insert_Task(quark, CORE_ztstrf_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(int), &nb, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, U, INOUT | QUARK_REGION_D | QUARK_REGION_U,
sizeof(int), &ldu, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INOUT | LOCALITY,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, L, OUTPUT,
sizeof(int), &ldl, VALUE,
sizeof(int)*nb, IPIV, OUTPUT,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &nb, VALUE,
sizeof(PLASMA_sequence*), &sequence, VALUE,
sizeof(PLASMA_request*), &request, VALUE,
sizeof(PLASMA_bool), &check_info, VALUE,
sizeof(int), &iinfo, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zttlqt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 244 of file core_zttlqt.c.

References CORE_zttlqt_quark(), DAG_CORE_TTLQT, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
DAG_CORE_TTLQT;
QUARK_Insert_Task(quark, CORE_zttlqt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT|QUARK_REGION_D|QUARK_REGION_L|LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zttmlq ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 259 of file core_zttmlq.c.

References CORE_zttmlq_quark(), DAG_CORE_TTMLQ, INOUT, INPUT, PlasmaLeft, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
DAG_CORE_TTMLQ;
QUARK_Insert_Task(quark, CORE_zttmlq_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zttmqr ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  V,
int  ldv,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 251 of file core_zttmqr.c.

References CORE_zttmqr_quark(), DAG_CORE_TTMQR, INOUT, INPUT, PlasmaLeft, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
DAG_CORE_TTMQR;
QUARK_Insert_Task(quark, CORE_zttmqr_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, V, INPUT|QUARK_REGION_D|QUARK_REGION_U,
sizeof(int), &ldv, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zttqrt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
PLASMA_Complex64_t *  A1,
int  lda1,
PLASMA_Complex64_t *  A2,
int  lda2,
PLASMA_Complex64_t *  T,
int  ldt 
)

Definition at line 244 of file core_zttqrt.c.

References CORE_zttqrt_quark(), DAG_CORE_TTQRT, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_U, SCRATCH, and VALUE.

{
DAG_CORE_TTQRT;
QUARK_Insert_Task(quark, CORE_zttqrt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A1, INOUT|QUARK_REGION_D|QUARK_REGION_U,
sizeof(int), &lda1, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A2, INOUT|QUARK_REGION_D|QUARK_REGION_U|LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb, NULL, SCRATCH,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zunmlq ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m,
int  n,
int  ib,
int  nb,
int  k,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  C,
int  ldc 
)

Definition at line 231 of file core_zunmlq.c.

References CORE_zunmlq_quark(), DAG_CORE_UNMLQ, INOUT, INPUT, QUARK_Insert_Task(), QUARK_REGION_U, SCRATCH, and VALUE.

{
DAG_CORE_UNMLQ;
QUARK_Insert_Task(quark, CORE_zunmlq_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT | QUARK_REGION_U,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &nb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_zunmqr ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m,
int  n,
int  k,
int  ib,
int  nb,
PLASMA_Complex64_t *  A,
int  lda,
PLASMA_Complex64_t *  T,
int  ldt,
PLASMA_Complex64_t *  C,
int  ldc 
)

Definition at line 224 of file core_zunmqr.c.

References CORE_zunmqr_quark(), DAG_CORE_UNMQR, INOUT, INPUT, QUARK_Insert_Task(), QUARK_REGION_L, SCRATCH, and VALUE.

{
DAG_CORE_UNMQR;
QUARK_Insert_Task(quark, CORE_zunmqr_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, A, INPUT | QUARK_REGION_L,
sizeof(int), &lda, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(PLASMA_Complex64_t)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
sizeof(PLASMA_Complex64_t)*ib*nb, NULL, SCRATCH,
sizeof(int), &nb, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function: