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
Advanced Interface: Asynchronous - Single Complex

Functions

int PLASMA_cgebrd_Tile_Async (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, float *D, float *E, PLASMA_desc *U, PLASMA_desc *VT, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgelqf_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgelqs_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgels_Tile_Async (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgemm_Tile_Async (PLASMA_enum transA, PLASMA_enum transB, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex32_t beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgeqrf_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgeqrs_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgesv_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgesv_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgesvd_Tile_Async (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, float *S, PLASMA_desc *U, PLASMA_desc *VT, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgetrf_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgetrf_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgetri_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_desc *W, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgetrs_Tile_Async (PLASMA_enum trans, PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cgetrs_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cheev_Tile_Async (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, float *W, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_chegst_Tile_Async (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_chegv_Tile_Async (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, float *W, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_chemm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex32_t beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cher2k_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, float beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cherk_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, float alpha, PLASMA_desc *A, float beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_chetrd_Tile_Async (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, float *D, float *E, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_clacpy_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_clange_Tile_Async (PLASMA_enum norm, PLASMA_desc *A, float *work, float *value, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_clanhe_Tile_Async (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A, float *work, float *value, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_clansy_Tile_Async (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A, float *work, float *value, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_claset_Tile_Async (PLASMA_enum uplo, PLASMA_Complex32_t alpha, PLASMA_Complex32_t beta, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_claswp_Tile_Async (PLASMA_desc *A, int K1, int K2, int *IPIV, int INCX, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_claswpc_Tile_Async (PLASMA_desc *A, int K1, int K2, int *IPIV, int INCX, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_clauum_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cplghe_Tile_Async (float bump, PLASMA_desc *A, unsigned long long int seed, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cplgsy_Tile_Async (PLASMA_Complex32_t bump, PLASMA_desc *A, unsigned long long int seed, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cplrnt_Tile_Async (PLASMA_desc *A, unsigned long long int seed, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cposv_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cpotrf_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cpotri_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cpotrs_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_csymm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex32_t beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_csyr2k_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_Complex32_t beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_csyrk_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_Complex32_t beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_ctrmm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_ctrsm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_ctrsmpl_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_ctrsmrv_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, PLASMA_Complex32_t alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_ctrtri_Tile_Async (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cunglq_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cungqr_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cunmlq_Tile_Async (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cunmqr_Tile_Async (PLASMA_enum side, PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cLapack_to_Tile_Async (PLASMA_Complex32_t *Af77, int LDA, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_cTile_to_Lapack_Async (PLASMA_desc *A, PLASMA_Complex32_t *Af77, int LDA, PLASMA_sequence *sequence, PLASMA_request *request)

Detailed Description

This is the group of single complex functions using the advanced asynchronous interface.


Function Documentation

int PLASMA_cgebrd_Tile_Async ( PLASMA_enum  jobu,
PLASMA_enum  jobvt,
PLASMA_desc A,
float *  D,
float *  E,
PLASMA_desc U,
PLASMA_desc VT,
PLASMA_desc T,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgebrd_Tile_Async - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Non-blocking equivalent of PLASMA_cgebrd_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgebrd
PLASMA_cgebrd_Tile
PLASMA_cgebrd_Tile_Async
PLASMA_dgebrd_Tile_Async
PLASMA_sgebrd_Tile_Async

Definition at line 383 of file cgebrd.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_4, plasma_dynamic_call_5, plasma_dynamic_call_7, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_NOT_SUPPORTED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_pcgerbb(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoVec, PlasmaUpper, PlasmaVec, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
plasma = plasma_context_self();
if (jobu != PlasmaNoVec && jobu !=PlasmaVec) {
plasma_error("PLASMA_cgebrd_Tile_Async", "illegal value of jobu");
}
if (jobvt != PlasmaNoVec && jobvt != PlasmaVec) {
plasma_error("PLASMA_cgebrd_Tile_Async", "illegal value of jobvt");
}
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgebrd_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgebrd_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgebrd_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgebrd_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu != PlasmaNoVec) && (plasma_desc_check(U) != PLASMA_SUCCESS)) {
plasma_error("PLASMA_cgebrd_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobvt != PlasmaNoVec) && (plasma_desc_check(VT) != PLASMA_SUCCESS) ) {
plasma_error("PLASMA_cgebrd_Tile_Async", "invalid fourth descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgebrd_Tile_Async", "invalid fifth descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgebrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (( (jobu != PlasmaNoVec) && (U->nb != U->mb) ) || ( (jobvt != PlasmaNoVec) && (VT->nb != VT->mb) )) {
plasma_error("PLASMA_cgebrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu == PlasmaVec) || (jobvt == PlasmaVec) ){
plasma_error("PLASMA_cgebrd_Tile_Async", "computing the singular vectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Reduction to bidiagonal form
* with a two-stage approach.
*/
/* Reduction to BAND bidiagonal form
* May be further optimized using the algo described in Trefethen
*/
/* if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) { */
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* } */
/* else { */
/* plasma_dynamic_call_4(plasma_pcgerbbrh, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Build the U of the first stage */
/* if (jobu == PlasmaVec){ */
/* /\* Initialize U to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descU, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pcungbr, */
/* PLASMA_enum, PlasmaLeft, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descU, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Build the VT of the first stage */
/* if (jobvt == PlasmaVec){ */
/* /\* Initialize VT to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descVT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pcungbr, */
/* PLASMA_enum, PlasmaRight, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descVT, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Set the V's to zero before the 2nd stage i.e., bulge chasing */
plasma_dynamic_call_5(plasma_pclaset2,
PLASMA_desc, descA.m >= descA.n ? descA : plasma_desc_submatrix(descA, descA.mb, 0, descA.m-descA.mb, descA.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_5(plasma_pclaset2,
PLASMA_desc, descA.m >= descA.n ? plasma_desc_submatrix(descA, 0, descA.nb, descA.m, descA.n-descA.nb) : descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Reduction from BAND bidiagonal to the final condensed form */
plasma_dynamic_call_7(plasma_pcgbrdb,
PLASMA_enum, descA.m >= descA.n ? PlasmaUpper : PlasmaLower,
PLASMA_desc, descA,
float*, D,
float*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgelqf_Tile_Async ( PLASMA_desc A,
PLASMA_desc T,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgelqf
PLASMA_cgelqf_Tile
PLASMA_cgelqf_Tile_Async
PLASMA_dgelqf_Tile_Async
PLASMA_sgelqf_Tile_Async
PLASMA_cgelqs_Tile_Async

Definition at line 235 of file cgelqf.c.

References A, plasma_context_struct::householder, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_parallel_call_4, plasma_pcgelqf(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgelqf_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgelqf_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgelqf_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgelqf_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgelqf_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgelqf_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, N) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pcgelqfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgelqs_Tile_Async ( PLASMA_desc A,
PLASMA_desc T,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgelqs_Tile_Async - Computes a minimum-norm solution using previously computed LQ factorization. Non-blocking equivalent of PLASMA_cgelqs_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgelqs
PLASMA_cgelqs_Tile
PLASMA_cgelqs_Tile_Async
PLASMA_dgelqs_Tile_Async
PLASMA_sgelqs_Tile_Async
PLASMA_cgelqf_Tile_Async

Definition at line 256 of file cgelqs.c.

References A, B, plasma_context_struct::householder, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_8, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_parallel_call_3, plasma_parallel_call_7, plasma_parallel_call_9, plasma_pctile_zero(), plasma_pctrsm(), plasma_pcunmlq(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgelqs_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgelqs_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgelqs_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgelqs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgelqs_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgelqs_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgelqs_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, min(N, NRHS)) == 0) {
return PLASMA_SUCCESS;
}
*/
PLASMA_desc, plasma_desc_submatrix(descB, descA.m, 0, descA.n-descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, plasma_desc_submatrix(descA, 0, 0, descA.m, descA.m),
PLASMA_desc, plasma_desc_submatrix(descB, 0, 0, descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pcunmlqrh,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgels_Tile_Async ( PLASMA_enum  trans,
PLASMA_desc A,
PLASMA_desc T,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgels_Tile_Async - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization. Non-blocking equivalent of PLASMA_cgels_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgels
PLASMA_cgels_Tile
PLASMA_cgels_Tile_Async
PLASMA_dgels_Tile_Async
PLASMA_sgels_Tile_Async

Definition at line 316 of file cgels.c.

References A, B, plasma_context_struct::householder, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_5, plasma_dynamic_call_8, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_NOT_SUPPORTED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_parallel_call_3, plasma_parallel_call_4, plasma_parallel_call_7, plasma_parallel_call_9, plasma_pcgelqf(), plasma_pcgeqrf(), plasma_pctile_zero(), plasma_pctrsm(), plasma_pcunmlq(), plasma_pcunmqr(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgels_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgels_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgels_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgels_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgels_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgels_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgels_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (trans != PlasmaNoTrans) {
plasma_error("PLASMA_cgels_Tile", "only PlasmaNoTrans supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_NOT_SUPPORTED);
}
/* Quick return - currently NOT equivalent to LAPACK's:
if (min(M, min(N, NRHS)) == 0) {
for (i = 0; i < max(M, N); i++)
for (j = 0; j < NRHS; j++)
B[j*LDB+i] = 0.0;
return PLASMA_SUCCESS;
}
*/
if (descA.m >= descA.n) {
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pcgeqrfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_8(plasma_pcunmqrrh,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
PLASMA_desc, plasma_desc_submatrix(descA, 0, 0, descA.n, descA.n),
PLASMA_desc, plasma_desc_submatrix(descB, 0, 0, descA.n, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
PLASMA_desc, plasma_desc_submatrix(descB, descA.m, 0, descA.n-descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pcgelqfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
PLASMA_desc, plasma_desc_submatrix(descA, 0, 0, descA.m, descA.m),
PLASMA_desc, plasma_desc_submatrix(descB, 0, 0, descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pcunmlqrh,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgemm_Tile_Async ( PLASMA_enum  transA,
PLASMA_enum  transB,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_Complex32_t  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgemm
PLASMA_cgemm_Tile
PLASMA_cgemm_Tile_Async
PLASMA_dgemm_Tile_Async
PLASMA_sgemm_Tile_Async

Definition at line 313 of file cgemm.c.

References A, B, C, plasma_desc_t::i, plasma_desc_t::j, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pcgemm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaNoTrans, PlasmaTrans, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
int M, N, K;
int Am, An, Ai, Aj, Amb, Anb;
int Bm, Bn, Bi, Bj, Bmb, Bnb;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgemm_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgemm_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgemm_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgemm_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgemm_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgemm_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((transA != PlasmaNoTrans) && (transA != PlasmaTrans) && (transA != PlasmaConjTrans)) {
plasma_error("PLASMA_cgemm_Tile_Async", "illegal value of transA");
return plasma_request_fail(sequence, request, -1);
}
if ((transB != PlasmaNoTrans) && (transB != PlasmaTrans) && (transB != PlasmaConjTrans)) {
plasma_error("PLASMA_cgemm_Tile_Async", "illegal value of transB");
return plasma_request_fail(sequence, request, -2);
}
if ( transA == PlasmaNoTrans ) {
Am = descA.m;
An = descA.n;
Amb = descA.mb;
Anb = descA.nb;
Ai = descA.i;
Aj = descA.j;
} else {
Am = descA.n;
An = descA.m;
Amb = descA.nb;
Anb = descA.mb;
Ai = descA.j;
Aj = descA.i;
}
if ( transB == PlasmaNoTrans ) {
Bm = descB.m;
Bn = descB.n;
Bmb = descB.mb;
Bnb = descB.nb;
Bi = descB.i;
Bj = descB.j;
} else {
Bm = descB.n;
Bn = descB.m;
Bmb = descB.nb;
Bnb = descB.mb;
Bi = descB.j;
Bj = descB.i;
}
if ( (Amb != descC.mb) || (Anb != Bmb) || (Bnb != descC.nb) ) {
plasma_error("PLASMA_cgemm_Tile_Async", "tile sizes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (Am != descC.m) || (An != Bm) || (Bn != descC.n) ) {
plasma_error("PLASMA_cgemm_Tile_Async", "sizes of matrices have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (Ai != descC.i) || (Aj != Bi) || (Bj != descC.j) ) {
plasma_error("PLASMA_cgemm_Tile_Async", "start indexes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
M = descC.m;
N = descC.n;
K = An;
/* Quick return */
if (M == 0 || N == 0 ||
((alpha == (PLASMA_Complex32_t)0.0 || K == 0) && beta == (PLASMA_Complex32_t)1.0))
PLASMA_enum, transA,
PLASMA_enum, transB,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgeqrf_Tile_Async ( PLASMA_desc A,
PLASMA_desc T,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgeqrf
PLASMA_cgeqrf_Tile
PLASMA_cgeqrf_Tile_Async
PLASMA_dgeqrf_Tile_Async
PLASMA_sgeqrf_Tile_Async
PLASMA_cgeqrs_Tile_Async

Definition at line 234 of file cgeqrf.c.

References A, plasma_context_struct::householder, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_parallel_call_4, plasma_pcgeqrf(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_error("PLASMA_cgeqrf_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgeqrf_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgeqrf_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgeqrf_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgeqrf_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgeqrf_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, N) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pcgeqrfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgeqrs_Tile_Async ( PLASMA_desc A,
PLASMA_desc T,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgeqrs_Tile_Async - Computes a minimum-norm solution using the tile QR factorization. Non-blocking equivalent of PLASMA_cgeqrs_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgeqrs
PLASMA_cgeqrs_Tile
PLASMA_cgeqrs_Tile_Async
PLASMA_dgeqrs_Tile_Async
PLASMA_sgeqrs_Tile_Async
PLASMA_cgeqrf_Tile_Async

Definition at line 255 of file cgeqrs.c.

References A, B, plasma_context_struct::householder, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_8, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_parallel_call_7, plasma_parallel_call_9, plasma_pctrsm(), plasma_pcunmqr(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgeqrs_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgeqrs_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgeqrs_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgeqrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgeqrs_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgeqrs_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgeqrs_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, min(N, NRHS)) == 0) {
return PLASMA_SUCCESS;
}
*/
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pcunmqrrh,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
PLASMA_desc, plasma_desc_submatrix(descA, 0, 0, descA.n, descA.n),
PLASMA_desc, plasma_desc_submatrix(descB, 0, 0, descA.n, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgesv_incpiv_Tile_Async ( PLASMA_desc A,
PLASMA_desc L,
int *  IPIV,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgesv_incpiv
PLASMA_cgesv_incpiv_Tile
PLASMA_cgesv_incpiv_Tile_Async
PLASMA_dgesv_incpiv_Tile_Async
PLASMA_sgesv_incpiv_Tile_Async
PLASMA_ccgesv_Tile_Async

Definition at line 252 of file cgesv_incpiv.c.

References A, B, L, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_parallel_call_6, plasma_parallel_call_9, plasma_pcgetrf_incpiv(), plasma_pctrsm(), plasma_pctrsmpl(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descL = *L;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgesv_incpiv_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgesv_incpiv_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgesv_incpiv_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgesv_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgesv_incpiv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgesv_incpiv_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgesv_incpiv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgesv_Tile_Async ( PLASMA_desc A,
int *  IPIV,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgesv
PLASMA_cgesv_Tile
PLASMA_cgesv_Tile_Async
PLASMA_dgesv_Tile_Async
PLASMA_sgesv_Tile_Async
PLASMA_ccgesv_Tile_Async

Definition at line 236 of file cgesv.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_4, plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pctrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgesv_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgesv_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgesv_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgesv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgesv_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgesv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pcgetrf_rectil,
PLASMA_desc, descA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pclaswp,
PLASMA_desc, descB,
int *, IPIV,
int, 1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgesvd_Tile_Async ( PLASMA_enum  jobu,
PLASMA_enum  jobvt,
PLASMA_desc A,
float *  S,
PLASMA_desc U,
PLASMA_desc VT,
PLASMA_desc T,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgesvd_Tile_Async - computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. Non-blocking equivalent of PLASMA_cgesvd_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgesvd
PLASMA_cgesvd_Tile
PLASMA_cgesvd_Tile_Async
PLASMA_dgesvd_Tile_Async
PLASMA_sgesvd_Tile_Async

Definition at line 383 of file cgesvd.c.

References A, lapack_const, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_4, plasma_dynamic_call_5, plasma_dynamic_call_7, plasma_dynamic_sync, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_NOT_SUPPORTED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_pcgerbb(), plasma_request_fail(), plasma_shared_alloc(), plasma_shared_free(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoVec, PlasmaRealDouble, PlasmaUpper, PlasmaVec, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
float *E;
int minMN = min(descA.m, descA.n);
int NCVT = 0;
int NRU = 0;
int NCC = 0;
plasma = plasma_context_self();
if (jobu != PlasmaNoVec && jobu !=PlasmaVec) {
plasma_error("PLASMA_cgesvd_Tile_Async", "illegal value of jobu");
}
if (jobvt != PlasmaNoVec && jobvt != PlasmaVec) {
plasma_error("PLASMA_cgesvd_Tile_Async", "illegal value of jobvt");
}
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgesvd_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgesvd_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgesvd_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgesvd_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu != PlasmaNoVec) && (plasma_desc_check(U) != PLASMA_SUCCESS)) {
plasma_error("PLASMA_cgesvd_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobvt != PlasmaNoVec) && (plasma_desc_check(VT) != PLASMA_SUCCESS) ) {
plasma_error("PLASMA_cgesvd_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgesvd_Tile_Async", "invalid fourth descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgesvd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (( (jobu != PlasmaNoVec) && (U->nb != U->mb) ) || ( (jobvt != PlasmaNoVec) && (VT->nb != VT->mb) )) {
plasma_error("PLASMA_cgesvd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu == PlasmaVec) || (jobvt == PlasmaVec) ){
plasma_error("PLASMA_cgesvd_Tile_Async", "computing the singular vectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
E = (float *)plasma_shared_alloc(plasma, minMN-1, PlasmaRealDouble);
/*
* Reduction to bidiagonal form with a two-stage approach.
*/
/*
* 1: Reduction to BAND bidiagonal form
* May be further optimized using the algo described in Trefethen
*/
/* if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) { */
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* } */
/* else { */
/* plasma_dynamic_call_4(plasma_pcgerbbrh, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Build the U of the first stage */
/* if (jobu == PlasmaVec){ */
/* /\* Initialize U to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descU, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) { */
/* plasma_dynamic_call_6(plasma_pcungbr, */
/* PLASMA_enum, PlasmaLeft, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descU, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* else { */
/* plasma_dynamic_call_6(plasma_pcungbrrh, */
/* PLASMA_enum, PlasmaLeft, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descU, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* } */
/* Build the VT of the first stage */
/* if (jobvt == PlasmaVec){ */
/* /\* Initialize VT to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descVT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) { */
/* plasma_dynamic_call_6(plasma_pcungbr, */
/* PLASMA_enum, PlasmaRight, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descVT, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* else { */
/* plasma_dynamic_call_6(plasma_pcungbrrh, */
/* PLASMA_enum, PlasmaRight, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descVT, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* } */
/*
* Set the V's to zero before the 2nd stage i.e., bulge chasing
*/
plasma_dynamic_call_5(plasma_pclaset2,
PLASMA_desc, descA.m >= descA.n ? descA : plasma_desc_submatrix(descA, descA.mb, 0, descA.m-descA.mb, descA.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_5(plasma_pclaset2,
PLASMA_desc, descA.m >= descA.n ? plasma_desc_submatrix(descA, 0, descA.nb, descA.m, descA.n-descA.nb) : descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* 2: Reduction from BAND bidiagonal to the final condensed form
*/
plasma_dynamic_call_7(plasma_pcgbrdb,
PLASMA_enum, descA.m >= descA.n ? PlasmaUpper : PlasmaLower,
PLASMA_desc, descA,
float*, S,
float*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Compute the singular values ONLY for now
*/
if (descA.m >= descA.n)
LAPACKE_cbdsqr(
LAPACK_COL_MAJOR, lapack_const(PlasmaUpper),
minMN, NCVT, NRU, NCC,
S, E,
NULL, 1, NULL, 1, NULL, 1 );
else {
LAPACKE_cbdsqr(
LAPACK_COL_MAJOR, lapack_const(PlasmaLower),
minMN, NCVT, NRU, NCC,
S, E,
NULL, 1, NULL, 1, NULL, 1 );
}
plasma_shared_free(plasma, E);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgetrf_incpiv_Tile_Async ( PLASMA_desc A,
PLASMA_desc L,
int *  IPIV,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgetrf_incpiv
PLASMA_cgetrf_incpiv_Tile
PLASMA_cgetrf_incpiv_Tile_Async
PLASMA_dgetrf_incpiv_Tile_Async
PLASMA_sgetrf_incpiv_Tile_Async
PLASMA_cgetrs_incpiv_Tile_Async

Definition at line 232 of file cgetrf_incpiv.c.

References A, L, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_pcgetrf_incpiv(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descL = *L;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgetrf_incpiv_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgetrf_incpiv_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgetrf_incpiv_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgetrf_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgetrf_incpiv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgetrf_incpiv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, N) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgetrf_Tile_Async ( PLASMA_desc A,
int *  IPIV,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgetrf
PLASMA_cgetrf_Tile
PLASMA_cgetrf_Tile_Async
PLASMA_dgetrf_Tile_Async
PLASMA_sgetrf_Tile_Async
PLASMA_cgetrs_Tile_Async

Definition at line 237 of file cgetrf.c.

References A, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_4, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgetrf_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgetrf_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgetrf_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgetrf_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgetrf_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(M, N) == 0)
return PLASMA_SUCCESS;
*/
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pcgetrf_rectil,
PLASMA_desc, descA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_pnl2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgetri_Tile_Async ( PLASMA_desc A,
int *  IPIV,
PLASMA_desc W,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cgetri_Tile_Async - Computes the inverse of a matrix using the LU factorization computed by PLASMA_cgetrf. This method inverts U and then computes inv(A) by solving the system inv(A)*L = inv(U) for inv(A). Non-blocking equivalent of PLASMA_cgetri_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgetri
PLASMA_cgetri_Tile
PLASMA_cgetri_Tile_Async
PLASMA_dgetri_Tile_Async
PLASMA_sgetri_Tile_Async
PLASMA_cgetrf_Tile_Async

Definition at line 233 of file cgetri.c.

References A, plasma_desc_t::m, max, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_5, plasma_dynamic_call_9, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_pctrsmrv(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, PlasmaUnit, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and W.

{
PLASMA_desc descA = *A;
PLASMA_desc descW = *W;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgetri_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgetri_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgetri_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgetri_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cgetri_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (max(descA.m, 0) == 0)
plasma_dynamic_call_5(plasma_pctrtri,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descW,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* No need for barrier tile2row because of previous dependencies */
/* swap */
plasma_pclaswpc,
PLASMA_desc, descA,
int *, IPIV,
int, -1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_row2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgetrs_incpiv_Tile_Async ( PLASMA_desc A,
PLASMA_desc L,
int *  IPIV,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgetrs_incpiv
PLASMA_cgetrs_incpiv_Tile
PLASMA_cgetrs_incpiv_Tile_Async
PLASMA_dgetrs_incpiv_Tile_Async
PLASMA_sgetrs_incpiv_Tile_Async
PLASMA_cgetrf_incpiv_Tile_Async

Definition at line 255 of file cgetrs_incpiv.c.

References A, B, L, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_6, plasma_parallel_call_9, plasma_pctrsm(), plasma_pctrsmpl(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descL = *L;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgetrs_incpiv_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgetrs_incpiv_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgetrs_incpiv_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgetrs_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgetrs_incpiv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgetrs_incpiv_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgetrs_incpiv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cgetrs_Tile_Async ( PLASMA_enum  trans,
PLASMA_desc A,
int *  IPIV,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cgetrs
PLASMA_cgetrs_Tile
PLASMA_cgetrs_Tile_Async
PLASMA_dgetrs_Tile_Async
PLASMA_sgetrs_Tile_Async
PLASMA_cgetrf_Tile_Async

Definition at line 248 of file cgetrs.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pctrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cgetrs_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cgetrs_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cgetrs_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cgetrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cgetrs_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cgetrs_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
if ( trans == PlasmaNoTrans )
{
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_pclaswp,
PLASMA_desc, descB,
int *, IPIV,
int, 1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_pclaswp,
PLASMA_desc, descB,
int *, IPIV,
int, -1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_pnl2tl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cheev_Tile_Async ( PLASMA_enum  jobz,
PLASMA_enum  uplo,
PLASMA_desc A,
float *  W,
PLASMA_desc T,
PLASMA_desc Q,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cheev_Tile_Async - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cheev
PLASMA_cheev_Tile
PLASMA_cheev_Tile_Async
PLASMA_dsyev_Tile_Async
PLASMA_ssyev_Tile_Async

Definition at line 326 of file cheev.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_5, plasma_dynamic_call_7, plasma_dynamic_sync, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), plasma_shared_alloc(), plasma_shared_free(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoVec, PlasmaRealDouble, PlasmaUpper, PlasmaVec, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
float *E;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cheev_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cheev_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cheev_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cheev_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cheev_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec){
plasma_error("PLASMA_cheev_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
}
/* Check input arguments */
if (jobz != PlasmaNoVec && jobz != PlasmaVec) {
plasma_error("PLASMA_cheev_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaLower && uplo != PlasmaUpper) {
plasma_error("PLASMA_cheev_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.m != descA.n) {
plasma_error("PLASMA_cheev_Tile_Async", "matrix need to be square");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cheev_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_cheev_Tile_Async", "computing the eigenvectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec){
if (Q->nb != Q->mb) {
plasma_error("PLASMA_cheev_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
}
E = (float *)plasma_shared_alloc(plasma, descA.n-1, PlasmaRealDouble);
/* Currently NOT equivalent to LAPACK's
*/
/* Reduction to tridiagonal form
* with a two-stage approach.
*/
/* Reduction to BAND tridiagonal form
*/
plasma_dynamic_call_5(plasma_pcherbt,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Build the Q of the first stage
*/
/* if (jobz == PlasmaVec){ */
/* /\* Initialize Q to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pcungtr, */
/* PLASMA_enum, uplo, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descQ, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Set the V's to zero before the 2nd stage (bulge chasing) */
plasma_pclaset2,
PLASMA_desc, uplo == PlasmaLower ? plasma_desc_submatrix(descA, descA.mb, 0, descA.m-descA.mb, descA.n-descA.nb) :
plasma_desc_submatrix(descA, 0, descA.nb, descA.m-descA.mb, descA.n-descA.nb),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Reduction from BAND tridiagonal to the final condensed form
*/
plasma_dynamic_call_7(plasma_pchbrdt,
PLASMA_desc, descA,
float*, W,
float*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* For eigenvalues only, call DSTERF.
* For eigenvectors, first call CUNGTR to generate the unitary matrix,
* then call ZSTEQR.
*/
if (jobz == PlasmaNoVec){
LAPACKE_ssterf(descA.n, W, E);
}else {
LAPACKE_ssterf(descA.n, W, E);
/* Accumulate the transformations from the second stage */
/*
plasma_dynamic_call_6(plasma_pcungtr,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
LAPACKE_csteqr(jobz, descA.n, W, E, Q->mat, Q->lm);
*/
}
/* If matrix was scaled, then rescale eigenvalues appropriately.
*/
plasma_shared_free(plasma, E);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_chegst_Tile_Async ( PLASMA_enum  itype,
PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_chegst_Tile_Async - reduces a complex Hermitian-definite generalized eigenproblem to standard form. If PlasmaItype == 1, the problem is A*x = lambda*B*x, and A is overwritten by inv(U**H)*A*inv(U) or inv(L)*A*inv(L**H) If PlasmaItype == 2 or 3, the problem is A*B*x = lambda*x or B*A*x = lambda*x, and A is overwritten by U*A*U**H or L**H*A*L. B must have been previously factorized as U**H*U or L*L**H by PLASMA_CPOTRF. ONLY PlasmaItype == 1 and PlasmaLower supported! Non-blocking equivalent of PLASMA_chegst_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_chegst
PLASMA_chegst_Tile
PLASMA_chegst_Tile_Async
PLASMA_dsygst_Tile_Async
PLASMA_ssygst_Tile_Async
PLASMA_chegv_Tile_Async

Definition at line 291 of file chegst.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_6, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_chegst_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_chegst_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_chegst_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_chegst_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chegst_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_chegst_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/*
* Transform Hermitian-definite generalized eigenproblem
* to standard form
*/
plasma_dynamic_call_6(plasma_pchegst,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_chegv_Tile_Async ( PLASMA_enum  itype,
PLASMA_enum  jobz,
PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_desc B,
float *  W,
PLASMA_desc T,
PLASMA_desc Q,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_chegv_Tile - Computes all eigenvalues and, optionally, eigenvectors of a complex generalized Hermitian-definite eigenproblem of the form: A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x. Here A and B are assumed to be Hermitian and B is also positive definite.

Non-blocking equivalent of PLASMA_chegv_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_chegv
PLASMA_chegv_Tile
PLASMA_chegv_Tile_Async
PLASMA_dsygv_Tile_Async
PLASMA_ssygv_Tile_Async

Definition at line 424 of file chegv.c.

References A, B, plasma_desc_t::ln, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_5, plasma_dynamic_call_6, plasma_dynamic_call_7, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_pcpotrf(), plasma_request_fail(), plasma_shared_alloc(), plasma_shared_free(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoVec, PlasmaRealDouble, PlasmaUpper, PlasmaVec, plasma_request_t::status, plasma_sequence_t::status, and T.

{
int status;
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descT = *T;
float *E;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_chegv_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_chegv_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_chegv_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_chegv_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chegv_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chegv_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec){
plasma_error("PLASMA_chegv_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
}
/* Check input arguments */
if (itype != 1 && itype != 2 && itype != 3) {
plasma_error("PLASMA_chegv_Tile_Async", "Illegal value of itype");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz != PlasmaNoVec && jobz != PlasmaVec) {
plasma_error("PLASMA_chegv_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaLower && uplo != PlasmaUpper) {
plasma_error("PLASMA_cheev_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.nb != descA.mb) {
plasma_error("PLASMA_chegv_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_chegv_Tile_Async", "computing the eigenvectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (jobz == PlasmaVec) && (Q->nb != Q->mb) ) {
plasma_error("PLASMA_chegv_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
E = (float *)plasma_shared_alloc(plasma, descA.n-1, PlasmaRealDouble);
/* Currently NOT equivalent to LAPACK's
*/
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
status = sequence->status;
if (status != 0){
status = descA.ln + status;
return status;
}
/*
* Transform problem to standard eigenvalue problem and solve
*/
plasma_dynamic_call_6(plasma_pchegst,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Reduction to tridiagonal form
* with a two-stage approach.
*/
/*
*Reduction to BAND tridiagonal form
*/
plasma_dynamic_call_5(plasma_pcherbt,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Build the Q of the first stage
*/
/* if (jobz == PlasmaVec){ */
/* /\* Initialize Q to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pcungtr, */
/* PLASMA_enum, uplo, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descQ, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Set the V's to zero before the 2nd stage (bulge chasing) */
plasma_pclaset2,
PLASMA_desc, uplo == PlasmaLower ? plasma_desc_submatrix(descA, descA.mb, 0, descA.m-descA.mb, descA.n-descA.nb) :
plasma_desc_submatrix(descA, 0, descA.nb, descA.m-descA.mb, descA.n-descA.nb),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Reduction from BAND tridiagonal to the final condensed form
*/
plasma_dynamic_call_7(plasma_pchbrdt,
PLASMA_desc, descA,
float*, W,
float*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* For eigenvalues only, call DSTERF.
* For eigenvectors, first call CUNGTR to generate the unitary matrix,
* then call ZSTEQR.
*/
if (jobz == PlasmaNoVec)
status = LAPACKE_ssterf(descA.n, W, E);
else {
status = LAPACKE_ssterf(descA.n, W, E);
/* Accumulate the transformations from the second stage */
/*
plasma_dynamic_call_6(plasma_pcungtr,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
LAPACKE_csteqr(jobz, descA.n, W, E, descQ.mat, descQ.lm);
*/
}
/* If matrix was scaled, then rescale eigenvalues appropriately.
*/
plasma_shared_free(plasma, E);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_chemm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_Complex32_t  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_chemm
PLASMA_chemm_Tile
PLASMA_chemm_Tile_Async
PLASMA_dhemm_Tile_Async
PLASMA_shemm_Tile_Async

Definition at line 303 of file chemm.c.

References A, B, C, plasma_desc_t::i, plasma_desc_t::j, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pchemm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_chemm_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_chemm_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_chemm_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_chemm_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chemm_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chemm_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ( (side != PlasmaLeft) && (side != PlasmaRight) ){
plasma_error("PLASMA_chemm_Tile_Async", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if ((uplo != PlasmaLower) && (uplo != PlasmaUpper)) {
plasma_error("PLASMA_chemm_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
/* Check matrices sizes */
if ( (descB.m != descC.m) || (descB.n != descC.n) ) {
plasma_error("PLASMA_chemm_Tile_Async", "B and C must have the same size");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descA.m != descA.n) ||
( (side == PlasmaLeft) && (descA.m != descB.m ) ) ||
( (side == PlasmaRight) && (descA.m != descB.n ) ) ) {
plasma_error("PLASMA_chemm_Tile_Async", "Matrix A must be square of size M or N regarding side.");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check tiles sizes */
if ( (descB.mb != descC.mb) || (descB.nb != descC.nb) ) {
plasma_error("PLASMA_chemm_Tile_Async", "B and C must have the same tile sizes");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descA.mb != descA.nb) ||
( (side == PlasmaLeft) && (descA.mb != descB.mb ) ) ||
( (side == PlasmaRight) && (descA.mb != descB.nb ) ) ) {
plasma_error("PLASMA_chemm_Tile_Async", "Matrix A must be square with square tiles wich fits the reagding tile size of B and C");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check submatrix starting point */
/* if ( (descB.i != descC.i) || (descB.j != descC.j) ) { */
/* plasma_error("PLASMA_chemm_Tile_Async", "B and C submatrices doesn't match"); */
/* return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE); */
/* } */
/* if ( (descA.i != descA.j) || */
/* ( (side == PlasmaLeft) && (descA.i != descB.i ) ) || */
/* ( (side == PlasmaRight) && (descA.i != descB.j ) ) ) { */
/* plasma_error("PLASMA_chemm_Tile_Async", "Submatrix A must start on diagnonal and match submatrices B and C."); */
/* return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE); */
/* } */
if( (descA.i != 0) || (descA.j != 0) ||
(descB.i != 0) || (descB.j != 0) ||
(descC.i != 0) || (descC.j != 0) ) {
plasma_error("PLASMA_chemm_Tile_Async", "Submatrices are not supported for now");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (descC.m == 0 || descC.n == 0 ||
( (alpha == (PLASMA_Complex32_t)0.0) && (beta == (PLASMA_Complex32_t)1.0) ))
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cher2k_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
float  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cher2k_Tile_Async - Performs Hermitian rank-k update. Non-blocking equivalent of PLASMA_cher2k_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cher2k
PLASMA_cher2k_Tile
PLASMA_cher2k_Tile_Async
PLASMA_dher2k_Tile_Async
PLASMA_sher2k_Tile_Async

Definition at line 299 of file cher2k.c.

References A, B, C, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pcher2k(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLower, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
int N, K;
int Am, An, Amb;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cher2k_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cher2k_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cher2k_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cher2k_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cher2k_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cher2k_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((uplo != PlasmaUpper) && (uplo != PlasmaLower)) {
plasma_error("PLASMA_cher2k", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
plasma_error("PLASMA_cher2k", "illegal value of trans");
return plasma_request_fail(sequence, request, -2);
}
if ( trans == PlasmaNoTrans ) {
Am = descA.m;
An = descA.n;
Amb = descA.mb;
} else {
Am = descA.n;
An = descA.m;
Amb = descA.nb;
}
if (descC.mb != descC.nb) {
plasma_error("PLASMA_cher2k_Tile_Async", "only square tiles for C are supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descB.mb != descA.mb) || (descB.nb != descA.nb) || (Amb != descC.mb) ){
plasma_error("PLASMA_cher2k_Tile_Async", "tile sizes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descC.m != descC.n) {
plasma_error("PLASMA_cher2k_Tile_Async", "only square matrix C is supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descB.m != descA.m) || (descB.n != descA.n) || (Am != descC.m) ){
plasma_error("PLASMA_cher2k_Tile_Async", "sizes of matrices have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
N = descC.m;
K = An;
/* Quick return */
if ( N == 0 ||
((alpha == (PLASMA_Complex32_t)0.0 || K == 0) && beta == (float)1.0))
PLASMA_desc, descA,
PLASMA_desc, descB,
float, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cherk_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
float  alpha,
PLASMA_desc A,
float  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cherk_Tile_Async - Performs Hermitian rank-k update. Non-blocking equivalent of PLASMA_cherk_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cherk
PLASMA_cherk_Tile
PLASMA_cherk_Tile_Async
PLASMA_dherk_Tile_Async
PLASMA_sherk_Tile_Async

Definition at line 276 of file cherk.c.

References A, C, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_8, plasma_pcherk(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLower, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descC = *C;
int N, K;
int Am, An, Amb;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cherk_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cherk_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cherk_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cherk_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cherk_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((uplo != PlasmaUpper) && (uplo != PlasmaLower)) {
plasma_error("PLASMA_cherk", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
plasma_error("PLASMA_cherk", "illegal value of transA");
return plasma_request_fail(sequence, request, -2);
}
if ( trans == PlasmaNoTrans ) {
Am = descA.m;
An = descA.n;
Amb = descA.mb;
} else {
Am = descA.n;
An = descA.m;
Amb = descA.nb;
}
if (descC.mb != descC.nb) {
plasma_error("PLASMA_cherk_Tile_Async", "only square tiles are supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (Amb != descC.mb) {
plasma_error("PLASMA_cherk_Tile_Async", "tile sizes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descC.m != descC.n) {
plasma_error("PLASMA_cherk_Tile_Async", "only square matrix C is supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (Am != descC.m) {
plasma_error("PLASMA_cherk_Tile_Async", "sizes of matrices have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
N = descC.m;
K = An;
/* Quick return */
if ( N == 0 ||
((alpha == (float)0.0 || K == 0) && beta == (float)1.0))
float, alpha,
PLASMA_desc, descA,
float, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_chetrd_Tile_Async ( PLASMA_enum  jobz,
PLASMA_enum  uplo,
PLASMA_desc A,
float *  D,
float *  E,
PLASMA_desc T,
PLASMA_desc Q,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_chetrd_Tile_Async - Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix A using a two-stage approach: First stage: reduction to band tridiagonal form; Second stage: reduction from band to tridiagonal form.

May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_chetrd
PLASMA_chetrd_Tile
PLASMA_chetrd_Tile_Async
PLASMA_dsytrd_Tile_Async
PLASMA_ssytrd_Tile_Async

Definition at line 331 of file chetrd.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_desc_submatrix(), plasma_dynamic_call_5, plasma_dynamic_call_7, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoVec, PlasmaVec, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_chetrd_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_chetrd_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_chetrd_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_chetrd_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_chetrd_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (jobz == PlasmaVec) && (plasma_desc_check(Q) != PLASMA_SUCCESS) ) {
plasma_error("PLASMA_chetrd_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (jobz != PlasmaNoVec && jobz != PlasmaVec) {
plasma_error("PLASMA_chetrd_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.m != descA.n) {
plasma_error("PLASMA_chetrd_Tile_Async", "matrix need to be square");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.nb != descA.mb) {
plasma_error("PLASMA_chetrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_chetrd_Tile_Async", "computing the eigenvectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (jobz == PlasmaVec) && (Q->nb != Q->mb) ) {
plasma_error("PLASMA_chetrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Reduction to tridiagonal form
* with a two-stage approach.
*/
/* Reduction to BAND tridiagonal form
*/
plasma_dynamic_call_5(plasma_pcherbt,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Build the Q of the first stage
*/
/* if (jobz == PlasmaVec){ */
/* /\* Initialize Q to Identity *\/ */
/* plasma_dynamic_call_6(plasma_pclaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* PLASMA_Complex32_t, 0.0, */
/* PLASMA_Complex32_t, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage*\/ */
/* plasma_dynamic_call_6(plasma_pcungtr, */
/* PLASMA_enum, uplo, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descQ, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* Set the V's to zero before the 2nd stage (bulge chasing) */
/*
*/
plasma_dynamic_call_5(plasma_pclaset2,
PLASMA_desc, uplo == PlasmaLower ? plasma_desc_submatrix(descA, descA.mb, 0, descA.m-descA.mb, descA.n-descA.nb)
: plasma_desc_submatrix(descA, 0, descA.nb, descA.m-descA.mb, descA.n-descA.nb),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Reduction from BAND tridiagonal to the final condensed form
*/
plasma_dynamic_call_7(plasma_pchbrdt,
PLASMA_desc, descA,
float*, D,
float*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_clacpy_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_clacpy_Tile_Async - Non-blocking equivalent of PLASMA_clacpy_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_clacpy
PLASMA_clacpy_Tile
PLASMA_clacpy_Tile_Async
PLASMA_dlacpy_Tile_Async
PLASMA_slacpy_Tile_Async

Definition at line 227 of file clacpy.c.

References A, B, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_pclacpy(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, PlasmaUpperLower, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_clacpy_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_clacpy_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_clacpy_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_clacpy_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_clacpy_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ( (uplo != PlasmaUpperLower) &&
(uplo != PlasmaUpper) &&
(uplo != PlasmaLower) ) {
plasma_error("PLASMA_clacpy_Tile_Async", "illegal value of uplo");
return -1;
}
/* Quick return */
if (min(descA.m, descA.n) == 0) {
}
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_clange_Tile_Async ( PLASMA_enum  norm,
PLASMA_desc A,
float *  work,
float *  value,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_clange_Tile_Async - Non-blocking equivalent of PLASMA_clange_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_clange
PLASMA_clange_Tile
PLASMA_clange_Tile_Async
PLASMA_dlange_Tile_Async
PLASMA_slange_Tile_Async

Definition at line 238 of file clange.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_6, plasma_pclange(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaMaxNorm, PlasmaOneNorm, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_clange_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_clange_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_clange_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_clange_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_clange_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_clange", "illegal value of norm");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (min(descA.m, descA.n) == 0) {
*value = 0.0;
}
PLASMA_desc, descA,
float*, work,
float*, value,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_clanhe_Tile_Async ( PLASMA_enum  norm,
PLASMA_enum  uplo,
PLASMA_desc A,
float *  work,
float *  value,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_clanhe_Tile_Async - Non-blocking equivalent of PLASMA_clanhe_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_clanhe
PLASMA_clanhe_Tile
PLASMA_clanhe_Tile_Async
PLASMA_dlanhe_Tile_Async
PLASMA_slanhe_Tile_Async

Definition at line 240 of file clanhe.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_7, plasma_pclanhe(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaLower, PlasmaMaxNorm, PlasmaOneNorm, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_clanhe_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_clanhe_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_clanhe_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_clanhe_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_clanhe_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_clanhe_Tile", "illegal value of norm");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (uplo != PlasmaUpper) && (uplo != PlasmaLower) ) {
plasma_error("PLASMA_clanhe_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if ( descA.m == 0) {
*value = 0.0;
}
PLASMA_desc, descA,
float*, work,
float*, value,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_clansy_Tile_Async ( PLASMA_enum  norm,
PLASMA_enum  uplo,
PLASMA_desc A,
float *  work,
float *  value,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_clansy_Tile_Async - Non-blocking equivalent of PLASMA_clansy_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_clansy
PLASMA_clansy_Tile
PLASMA_clansy_Tile_Async
PLASMA_dlansy_Tile_Async
PLASMA_slansy_Tile_Async

Definition at line 240 of file clansy.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_7, plasma_pclansy(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaLower, PlasmaMaxNorm, PlasmaOneNorm, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_clansy_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_clansy_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_clansy_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_clansy_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_clansy_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_clansy_Tile", "illegal value of norm");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (uplo != PlasmaUpper) && (uplo != PlasmaLower) ) {
plasma_error("PLASMA_clansy_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if ( descA.m == 0) {
*value = 0.0;
}
PLASMA_desc, descA,
float*, work,
float*, value,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cLapack_to_Tile_Async ( PLASMA_Complex32_t Af77,
int  LDA,
PLASMA_desc A,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]Af77LAPACK matrix.
[in]LDAThe leading dimension of the matrix Af77.
[in,out]ADescriptor of the PLASMA matrix in tile layout. If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE, A->mat is not used and set to Af77 when returns, else if PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE, A->mat has to be allocated before.
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cTile_to_Lapack_Async
PLASMA_cLapack_to_Tile
PLASMA_cLapack_to_Tile_Async
PLASMA_dLapack_to_Tile_Async
PLASMA_sLapack_to_Tile_Async

Definition at line 128 of file ctile.c.

References A, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_pclapack_to_tile(), and PLASMA_SUCCESS.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cLapack_to_Tile", "PLASMA not initialized");
}
/* Check descriptor for correctness */
plasma_error("PLASMA_cLapack_to_Tile", "invalid descriptor");
}
int, LDA,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

int PLASMA_claset_Tile_Async ( PLASMA_enum  uplo,
PLASMA_Complex32_t  alpha,
PLASMA_Complex32_t  beta,
PLASMA_desc A,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_claset_Tile_Async - Non-blocking equivalent of PLASMA_claset_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_claset
PLASMA_claset_Tile
PLASMA_claset_Tile_Async
PLASMA_dlaset_Tile_Async
PLASMA_slaset_Tile_Async

Definition at line 218 of file claset.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_6, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, PlasmaUpperLower, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_claset_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_claset_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_claset_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_claset_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_claset_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ( (uplo != PlasmaUpperLower) &&
(uplo != PlasmaUpper) &&
(uplo != PlasmaLower) ) {
plasma_error("PLASMA_claset_Tile_Async", "illegal value of uplo");
return -1;
}
/* Quick return */
if (min(descA.m, descA.n) == 0) {
}
plasma_dynamic_call_6(plasma_pclaset,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_claswp_Tile_Async ( PLASMA_desc A,
int  K1,
int  K2,
int *  IPIV,
int  INCX,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_claswp_Tile_Async - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Non-blocking equivalent of PLASMA_claswp_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_claswp
PLASMA_claswp_Tile
PLASMA_claswp_Tile_Async
PLASMA_dlaswp_Tile_Async
PLASMA_slaswp_Tile_Async
PLASMA_cgetrf_Tile_Async

Definition at line 226 of file claswp.c.

References A, plasma_desc_t::m, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_claswp_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_claswp_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_claswp_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_claswp_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (K1 != 1) || (K2 != descA.m) ) {
plasma_error("PLASMA_claswp_Tile", "invalid K1 or K2 (1..M is the only interval supported right now)");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_pcbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_pclaswp,
PLASMA_desc, descA,
int *, IPIV,
int, INCX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_pnl2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_claswpc_Tile_Async ( PLASMA_desc A,
int  K1,
int  K2,
int *  IPIV,
int  INCX,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_claswpc_Tile_Async - performs a series of row interchanges on the matrix A. One row interchange is initiated for each of rows K1 through K2 of A. Non-blocking equivalent of PLASMA_claswpc_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_claswpc
PLASMA_claswpc_Tile
PLASMA_claswpc_Tile_Async
PLASMA_dlaswpc_Tile_Async
PLASMA_slaswpc_Tile_Async
PLASMA_cgetrf_Tile_Async

Definition at line 226 of file claswpc.c.

References A, plasma_desc_t::m, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_3, plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_claswpc_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_claswpc_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_claswpc_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_claswpc_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (K1 != 1) || (K2 != descA.m) ) {
plasma_error("PLASMA_claswpc_Tile", "invalid K1 or K2 (1..M is the only interval supported right now)");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_pcbarrier_tl2row,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_pclaswpc,
PLASMA_desc, descA,
int *, IPIV,
int, INCX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_pcbarrier_row2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_clauum_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_clauum_Tile_Async - Computes the product U * U' or L' * L, where the triangular factor U or L is stored in the upper or lower triangular part of the array A. Non-blocking equivalent of PLASMA_clauum_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_clauum
PLASMA_clauum_Tile
PLASMA_clauum_Tile_Async
PLASMA_dlauum_Tile_Async
PLASMA_slauum_Tile_Async
PLASMA_cpotri_Tile_Async

Definition at line 222 of file clauum.c.

References A, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_4, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_clauum_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_clauum_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_clauum_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_clauum_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_clauum_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_clauum_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return */
/*
if (max(N, 0) == 0)
return PLASMA_SUCCESS;
*/
plasma_dynamic_call_4(plasma_pclauum,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cplghe_Tile_Async ( float  bump,
PLASMA_desc A,
unsigned long long int  seed,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cplghe
PLASMA_cplghe_Tile
PLASMA_cplghe_Tile_Async
PLASMA_dplghe_Tile_Async
PLASMA_splghe_Tile_Async
PLASMA_cplghe_Tile_Async
PLASMA_cplgsy_Tile_Async

Definition at line 203 of file cplghe.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_pcplghe(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cplghe_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cplghe_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cplghe_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cplghe_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cplghe_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (min( descA.m, descA.n ) == 0)
float, bump,
PLASMA_desc, descA,
unsigned long long int, seed,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cplgsy_Tile_Async ( PLASMA_Complex32_t  bump,
PLASMA_desc A,
unsigned long long int  seed,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cplgsy
PLASMA_cplgsy_Tile
PLASMA_cplgsy_Tile_Async
PLASMA_dplgsy_Tile_Async
PLASMA_splgsy_Tile_Async
PLASMA_cplgsy_Tile_Async
PLASMA_cplgsy_Tile_Async

Definition at line 203 of file cplgsy.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_5, plasma_pcplgsy(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cplgsy_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cplgsy_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cplgsy_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cplgsy_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cplgsy_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (min( descA.m, descA.n ) == 0)
PLASMA_desc, descA,
unsigned long long int, seed,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cplrnt_Tile_Async ( PLASMA_desc A,
unsigned long long int  seed,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cplrnt
PLASMA_cplrnt_Tile
PLASMA_cplrnt_Tile_Async
PLASMA_dplrnt_Tile_Async
PLASMA_splrnt_Tile_Async
PLASMA_cplghe_Tile_Async
PLASMA_cplgsy_Tile_Async

Definition at line 201 of file cplrnt.c.

References A, plasma_desc_t::m, plasma_desc_t::mb, min, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_pcplrnt(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cplrnt_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cplrnt_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cplrnt_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cplrnt_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cplrnt_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (min( descA.m, descA.n ) == 0)
PLASMA_desc, descA,
unsigned long long int, seed,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cposv_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cposv
PLASMA_cposv_Tile
PLASMA_cposv_Tile_Async
PLASMA_dposv_Tile_Async
PLASMA_sposv_Tile_Async

Definition at line 260 of file cposv.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_parallel_call_9, plasma_pcpotrf(), plasma_pctrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cposv_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cposv_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cposv_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cposv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cposv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cposv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_cposv_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return - currently NOT equivalent to LAPACK's
* LAPACK does not have such check for DPOSV */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cpotrf_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cpotrf
PLASMA_cpotrf_Tile
PLASMA_cpotrf_Tile_Async
PLASMA_dpotrf_Tile_Async
PLASMA_spotrf_Tile_Async
PLASMA_cpotrs_Tile_Async

Definition at line 232 of file cpotrf.c.

References A, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_pcpotrf(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cpotrf_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cpotrf_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cpotrf_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cpotrf_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cpotrf_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_cpotrf_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return */
/*
if (max(N, 0) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cpotri_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_cpotri_Tile_Async - Computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**H*U or A = L*L**H computed by PLASMA_cpotrf. Non-blocking equivalent of PLASMA_cpotri_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cpotri
PLASMA_cpotri_Tile
PLASMA_cpotri_Tile_Async
PLASMA_dpotri_Tile_Async
PLASMA_spotri_Tile_Async
PLASMA_cpotrf_Tile_Async

Definition at line 222 of file cpotri.c.

References A, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_4, plasma_dynamic_call_5, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNonUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cpotri_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cpotri_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cpotri_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cpotri_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_cpotri_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_cpotri_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return */
/*
if (max(N, 0) == 0)
return PLASMA_SUCCESS;
*/
plasma_dynamic_call_5(plasma_pctrtri,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pclauum,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cpotrs_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cpotrs
PLASMA_cpotrs_Tile
PLASMA_cpotrs_Tile_Async
PLASMA_dpotrs_Tile_Async
PLASMA_spotrs_Tile_Async
PLASMA_cpotrf_Tile_Async

Definition at line 236 of file cpotrs.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pctrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cpotrs_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_cpotrs_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_cpotrs_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_cpotrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_cpotrs_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_cpotrs_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_cpotrs_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_csymm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_Complex32_t  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_csymm
PLASMA_csymm_Tile
PLASMA_csymm_Tile_Async
PLASMA_dsymm_Tile_Async
PLASMA_ssymm_Tile_Async

Definition at line 303 of file csymm.c.

References A, B, C, plasma_desc_t::i, plasma_desc_t::j, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pcsymm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_csymm_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_csymm_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_csymm_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_csymm_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_csymm_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_csymm_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ( (side != PlasmaLeft) && (side != PlasmaRight) ){
plasma_error("PLASMA_csymm_Tile_Async", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if ((uplo != PlasmaLower) && (uplo != PlasmaUpper)) {
plasma_error("PLASMA_csymm_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
/* Check matrices sizes */
if ( (descB.m != descC.m) || (descB.n != descC.n) ) {
plasma_error("PLASMA_csymm_Tile_Async", "B and C must have the same size");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descA.m != descA.n) ||
( (side == PlasmaLeft) && (descA.m != descB.m ) ) ||
( (side == PlasmaRight) && (descA.m != descB.n ) ) ) {
plasma_error("PLASMA_csymm_Tile_Async", "Matrix A must be square of size M or N regarding side.");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check tiles sizes */
if ( (descB.mb != descC.mb) || (descB.nb != descC.nb) ) {
plasma_error("PLASMA_csymm_Tile_Async", "B and C must have the same tile sizes");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descA.mb != descA.nb) ||
( (side == PlasmaLeft) && (descA.mb != descB.mb ) ) ||
( (side == PlasmaRight) && (descA.mb != descB.nb ) ) ) {
plasma_error("PLASMA_csymm_Tile_Async", "Matrix A must be square with square tiles wich fits the reagding tile size of B and C");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check submatrix starting point */
/* if ( (descB.i != descC.i) || (descB.j != descC.j) ) { */
/* plasma_error("PLASMA_csymm_Tile_Async", "B and C submatrices doesn't match"); */
/* return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE); */
/* } */
/* if ( (descA.i != descA.j) || */
/* ( (side == PlasmaLeft) && (descA.i != descB.i ) ) || */
/* ( (side == PlasmaRight) && (descA.i != descB.j ) ) ) { */
/* plasma_error("PLASMA_csymm_Tile_Async", "Submatrix A must start on diagnonal and match submatrices B and C."); */
/* return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE); */
/* } */
if( (descA.i != 0) || (descA.j != 0) ||
(descB.i != 0) || (descB.j != 0) ||
(descC.i != 0) || (descC.j != 0) ) {
plasma_error("PLASMA_chemm_Tile_Async", "Submatrices are not supported for now");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (descC.m == 0 || descC.n == 0 ||
( (alpha == (PLASMA_Complex32_t)0.0) && (beta == (PLASMA_Complex32_t)1.0) ))
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_csyr2k_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_Complex32_t  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_csyr2k_Tile_Async - Performs symmetric rank-k update. Non-blocking equivalent of PLASMA_csyr2k_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_csyr2k
PLASMA_csyr2k_Tile
PLASMA_csyr2k_Tile_Async
PLASMA_dsyr2k_Tile_Async
PLASMA_ssyr2k_Tile_Async

Definition at line 299 of file csyr2k.c.

References A, B, C, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pcsyr2k(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
int N, K;
int Am, An, Amb;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_csyr2k_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_csyr2k_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_csyr2k_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_csyr2k_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_csyr2k_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_csyr2k_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((uplo != PlasmaUpper) && (uplo != PlasmaLower)) {
plasma_error("PLASMA_csyr2k", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
plasma_error("PLASMA_csyr2k", "illegal value of trans");
return plasma_request_fail(sequence, request, -2);
}
if ( trans == PlasmaNoTrans ) {
Am = descA.m;
An = descA.n;
Amb = descA.mb;
} else {
Am = descA.n;
An = descA.m;
Amb = descA.nb;
}
if (descC.mb != descC.nb) {
plasma_error("PLASMA_csyr2k_Tile_Async", "only square tiles for C are supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descB.mb != descA.mb) || (descB.nb != descA.nb) || (Amb != descC.mb) ){
plasma_error("PLASMA_csyr2k_Tile_Async", "tile sizes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descC.m != descC.n) {
plasma_error("PLASMA_csyr2k_Tile_Async", "only square matrix C is supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (descB.m != descA.m) || (descB.n != descA.n) || (Am != descC.m) ){
plasma_error("PLASMA_csyr2k_Tile_Async", "sizes of matrices have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
N = descC.m;
K = An;
/* Quick return */
if ( N == 0 ||
((alpha == (PLASMA_Complex32_t)0.0 || K == 0) && beta == (PLASMA_Complex32_t)1.0))
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_csyrk_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_Complex32_t  beta,
PLASMA_desc C,
PLASMA_sequence sequence,
PLASMA_request request 
)

PLASMA_csyrk_Tile_Async - Performs rank-k update. Non-blocking equivalent of PLASMA_csyrk_Tile(). May return before the computation is finished. Allows for pipelining of operations ar runtime.

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_csyrk
PLASMA_csyrk_Tile
PLASMA_csyrk_Tile_Async
PLASMA_dsyrk_Tile_Async
PLASMA_ssyrk_Tile_Async

Definition at line 276 of file csyrk.c.

References A, C, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_8, plasma_pcsyrk(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descC = *C;
int N, K;
int Am, An, Amb;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_csyrk_Tile_Async", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_csyrk_Tile_Async", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_csyrk_Tile_Async", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_csyrk_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_csyrk_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((uplo != PlasmaUpper) && (uplo != PlasmaLower)) {
plasma_error("PLASMA_csyrk", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
plasma_error("PLASMA_csyrk", "illegal value of transA");
return plasma_request_fail(sequence, request, -2);
}
if ( trans == PlasmaNoTrans ) {
Am = descA.m;
An = descA.n;
Amb = descA.mb;
} else {
Am = descA.n;
An = descA.m;
Amb = descA.nb;
}
if (descC.mb != descC.nb) {
plasma_error("PLASMA_csyrk_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (Amb != descC.mb) {
plasma_error("PLASMA_csyrk_Tile_Async", "tile sizes have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descC.m != descC.n) {
plasma_error("PLASMA_csyrk_Tile_Async", "only square matrix C is supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (Am != descC.m) {
plasma_error("PLASMA_csyrk_Tile_Async", "sizes of matrices have to match");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
N = descC.m;
K = An;
/* Quick return */
if ( N == 0 ||
((alpha == (PLASMA_Complex32_t)0.0 || K == 0) && beta == (PLASMA_Complex32_t)1.0))
PLASMA_desc, descA,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_cTile_to_Lapack_Async ( PLASMA_desc A,
PLASMA_Complex32_t Af77,
int  LDA,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]ADescriptor of the PLASMA matrix in tile layout.
[in,out]Af77LAPACK matrix. If PLASMA_TRANSLATION_MODE is set to PLASMA_INPLACE, Af77 has to be A->mat, else if PLASMA_TRANSLATION_MODE is set to PLASMA_OUTOFPLACE, Af77 has to be allocated before.
[in]LDAThe leading dimension of the matrix Af77.
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_cLapack_to_Tile_Async
PLASMA_cTile_to_Lapack
PLASMA_cTile_to_Lapack_Async
PLASMA_dTile_to_Lapack_Async
PLASMA_sTile_to_Lapack_Async

Definition at line 264 of file ctile.c.

References A, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, plasma_error(), plasma_fatal_error(), plasma_pctile_to_lapack(), plasma_static_call_5, and PLASMA_SUCCESS.

{
PLASMA_desc descA = *A;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_cTile_to_Lapack", "PLASMA not initialized");
}
/* Check descriptor for correctness */
plasma_error("PLASMA_cTile_to_Lapack", "invalid descriptor");
}
PLASMA_desc, descA,
int, LDA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

int PLASMA_ctrmm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_ctrmm
PLASMA_ctrmm_Tile
PLASMA_ctrmm_Tile_Async
PLASMA_dtrmm_Tile_Async
PLASMA_strmm_Tile_Async

Definition at line 298 of file ctrmm.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_9, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_pctrmm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, PlasmaTrans, PlasmaUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_ctrmm_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_ctrmm_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_ctrmm_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_ctrmm_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_ctrmm_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_ctrmm_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_ctrmm_Tile", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_ctrmm_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
if (transA != PlasmaConjTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
plasma_error("PLASMA_ctrmm_Tile", "illegal value of transA");
return plasma_request_fail(sequence, request, -3);
}
plasma_error("PLASMA_ctrmm_Tile", "illegal value of diag");
return plasma_request_fail(sequence, request, -4);
}
/* Quick return */
PLASMA_enum, transA,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_ctrsm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_ctrsm
PLASMA_ctrsm_Tile
PLASMA_ctrsm_Tile_Async
PLASMA_dtrsm_Tile_Async
PLASMA_strsm_Tile_Async

Definition at line 298 of file ctrsm.c.

References A, B, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_9, plasma_pctrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaConjTrans, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, PlasmaTrans, PlasmaUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_ctrsm_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_ctrsm_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_ctrsm_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_ctrsm_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_ctrsm_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_ctrsm_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_ctrsm_Tile", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_ctrsm_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
if (transA != PlasmaConjTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
plasma_error("PLASMA_ctrsm_Tile", "illegal value of transA");
return plasma_request_fail(sequence, request, -3);
}
plasma_error("PLASMA_ctrsm_Tile", "illegal value of diag");
return plasma_request_fail(sequence, request, -4);
}
/* Quick return */
PLASMA_enum, transA,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_ctrsmpl_Tile_Async ( PLASMA_desc A,
PLASMA_desc L,
int *  IPIV,
PLASMA_desc B,
PLASMA_sequence sequence,
PLASMA_request request 
)

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

Parameters:
[in]sequenceIdentifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes).
[out]requestIdentifies this function call (for exception handling purposes).
See also:
PLASMA_ctrsmpl
PLASMA_ctrsmpl_Tile
PLASMA_ctrsmpl_Tile_Async
PLASMA_dtrsmpl_Tile_Async
PLASMA_strsmpl_Tile_Async
PLASMA_cgetrf_incpiv_Tile_Async

Definition at line 240 of file ctrsmpl.c.

References A, B, L, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_6, plasma_pctrsmpl(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descL = *L;
PLASMA_desc descB = *B;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_ctrsmpl_Tile", "PLASMA not initialized");
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_ctrsmpl_Tile", "NULL sequence");
}
if (request == NULL) {
plasma_fatal_error("PLASMA_ctrsmpl_Tile", "NULL request");
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
/* Check descriptors for correctness */
plasma_error("PLASMA_ctrsmpl_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_ctrsmpl_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
plasma_error("PLASMA_ctrsmpl_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb) {
plasma_error("PLASMA_ctrsmpl_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_ctrsmrv_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
PLASMA_Complex32_t  alpha,
PLASMA_desc A,
PLASMA_desc B,