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
Functions
Advanced Interface: Asynchronous - Double Real

Functions

int PLASMA_dgebrd_Tile_Async (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, double *D, double *E, PLASMA_desc *U, PLASMA_desc *VT, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgelqf_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgelqs_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgels_Tile_Async (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgemm_Tile_Async (PLASMA_enum transA, PLASMA_enum transB, double alpha, PLASMA_desc *A, PLASMA_desc *B, double beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgeqrf_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgeqrs_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgesv_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgesv_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgesvd_Tile_Async (PLASMA_enum jobu, PLASMA_enum jobvt, PLASMA_desc *A, double *S, PLASMA_desc *U, PLASMA_desc *VT, PLASMA_desc *T, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetrf_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetrf_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetri_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_desc *W, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetrs_Tile_Async (PLASMA_enum trans, PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dgetrs_incpiv_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlacpy_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlange_Tile_Async (PLASMA_enum norm, PLASMA_desc *A, double *work, double *value, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlansy_Tile_Async (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc *A, double *work, double *value, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlaset_Tile_Async (PLASMA_enum uplo, double alpha, double beta, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlaswp_Tile_Async (PLASMA_desc *A, int K1, int K2, int *IPIV, int INCX, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlaswpc_Tile_Async (PLASMA_desc *A, int K1, int K2, int *IPIV, int INCX, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dlauum_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dorglq_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dorgqr_Tile_Async (PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dormlq_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_dormqr_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_dplgsy_Tile_Async (double bump, PLASMA_desc *A, unsigned long long int seed, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dplrnt_Tile_Async (PLASMA_desc *A, unsigned long long int seed, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dposv_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dpotrf_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dpotri_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dpotrs_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsgesv_Tile_Async (PLASMA_desc *A, int *IPIV, PLASMA_desc *B, PLASMA_desc *X, int *ITER, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsposv_Tile_Async (PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_desc *X, int *ITER, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsungesv_Tile_Async (PLASMA_enum trans, PLASMA_desc *A, PLASMA_desc *T, PLASMA_desc *B, PLASMA_desc *X, int *ITER, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsyev_Tile_Async (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, double *W, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsygst_Tile_Async (PLASMA_enum itype, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsygv_Tile_Async (PLASMA_enum itype, PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, PLASMA_desc *B, double *W, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsymm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, double alpha, PLASMA_desc *A, PLASMA_desc *B, double beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsyr2k_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, double alpha, PLASMA_desc *A, PLASMA_desc *B, double beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsyrk_Tile_Async (PLASMA_enum uplo, PLASMA_enum trans, double alpha, PLASMA_desc *A, double beta, PLASMA_desc *C, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dsytrd_Tile_Async (PLASMA_enum jobz, PLASMA_enum uplo, PLASMA_desc *A, double *D, double *E, PLASMA_desc *T, PLASMA_desc *Q, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dtrmm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, double alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dtrsm_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, double alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dtrsmpl_Tile_Async (PLASMA_desc *A, PLASMA_desc *L, int *IPIV, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dtrsmrv_Tile_Async (PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum transA, PLASMA_enum diag, double alpha, PLASMA_desc *A, PLASMA_desc *B, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dtrtri_Tile_Async (PLASMA_enum uplo, PLASMA_enum diag, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dLapack_to_Tile_Async (double *Af77, int LDA, PLASMA_desc *A, PLASMA_sequence *sequence, PLASMA_request *request)
int PLASMA_dTile_to_Lapack_Async (PLASMA_desc *A, double *Af77, int LDA, PLASMA_sequence *sequence, PLASMA_request *request)

Detailed Description

This is the group of double real functions using the advanced asynchronous interface.

Function Documentation

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

PLASMA_dgebrd_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_dgebrd_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_dgebrd
PLASMA_dgebrd_Tile
PLASMA_cgebrd_Tile_Async
PLASMA_dgebrd_Tile_Async
PLASMA_sgebrd_Tile_Async

Definition at line 383 of file dgebrd.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_pdgerbb(), 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_context_t *plasma;
plasma = plasma_context_self();
if (jobu != PlasmaNoVec && jobu !=PlasmaVec) {
plasma_error("PLASMA_dgebrd_Tile_Async", "illegal value of jobu");
return PLASMA_ERR_NOT_SUPPORTED;
}
if (jobvt != PlasmaNoVec && jobvt != PlasmaVec) {
plasma_error("PLASMA_dgebrd_Tile_Async", "illegal value of jobvt");
return PLASMA_ERR_NOT_SUPPORTED;
}
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgebrd_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgebrd_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgebrd_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgebrd_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_dgebrd_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_dgebrd_Tile_Async", "invalid fourth descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgebrd_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_dgebrd_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_dgebrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu == PlasmaVec) || (jobvt == PlasmaVec) ){
plasma_error("PLASMA_dgebrd_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_dynamic_call_4(plasma_pdgerbb,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* } */
/* else { */
/* plasma_dynamic_call_4(plasma_pdgerbbrh, */
/* 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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 1.0, */
/* PLASMA_desc, descU, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pdorgbr, */
/* 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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 1.0, */
/* PLASMA_desc, descVT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pdorgbr, */
/* 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_pdlaset2,
PLASMA_enum, PlasmaLower,
double, 0.0,
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_pdlaset2,
PLASMA_enum, PlasmaUpper,
double, 0.0,
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_pdgbrdb,
PLASMA_enum, descA.m >= descA.n ? PlasmaUpper : PlasmaLower,
PLASMA_desc, descA,
double*, D,
double*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
*/
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dgelqf_Tile_Async ( PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dgelqf_Tile_Async - Computes the tile LQ factorization of a matrix. Non-blocking equivalent of PLASMA_dgelqf_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_dgelqf
PLASMA_dgelqf_Tile
PLASMA_cgelqf_Tile_Async
PLASMA_dgelqf_Tile_Async
PLASMA_sgelqf_Tile_Async
PLASMA_dgelqs_Tile_Async

Definition at line 235 of file dgelqf.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_pdgelqf(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgelqf_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgelqf_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgelqf_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgelqf_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgelqf_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_dgelqf_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;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_4(plasma_pdgelqf,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pdgelqfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgelqs_Tile_Async - Computes a minimum-norm solution using previously computed LQ factorization. Non-blocking equivalent of PLASMA_dgelqs_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_dgelqs
PLASMA_dgelqs_Tile
PLASMA_cgelqs_Tile_Async
PLASMA_dgelqs_Tile_Async
PLASMA_sgelqs_Tile_Async
PLASMA_dgelqf_Tile_Async

Definition at line 256 of file dgelqs.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_pdormlq(), plasma_pdtile_zero(), plasma_pdtrsm(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgelqs_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgelqs_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgelqs_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgelqs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgelqs_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgelqs_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_dgelqs_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_parallel_call_3(plasma_pdtile_zero,
PLASMA_desc, plasma_desc_submatrix(descB, descA.m, 0, descA.n-descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaLower,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
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);
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_7(plasma_pdormlq,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pdormlqrh,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgels_Tile_Async - Solves overdetermined or underdetermined linear system of equations using the tile QR or the tile LQ factorization. Non-blocking equivalent of PLASMA_dgels_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_dgels
PLASMA_dgels_Tile
PLASMA_cgels_Tile_Async
PLASMA_dgels_Tile_Async
PLASMA_sgels_Tile_Async

Definition at line 316 of file dgels.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_pdgelqf(), plasma_pdgeqrf(), plasma_pdormlq(), plasma_pdormqr(), plasma_pdtile_zero(), plasma_pdtrsm(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgels_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgels_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgels_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgels_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgels_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgels_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_dgels_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (trans != PlasmaNoTrans) {
plasma_error("PLASMA_dgels_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) {
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_4(plasma_pdgeqrf,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_7(plasma_pdormqr,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pdgeqrfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_8(plasma_pdormqrrh,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
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_parallel_call_3(plasma_pdtile_zero,
PLASMA_desc, plasma_desc_submatrix(descB, descA.m, 0, descA.n-descA.m, descB.n),
PLASMA_sequence*, sequence,
PLASMA_request*, request);
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_4(plasma_pdgelqf,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pdgelqfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaLower,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
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);
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_7(plasma_pdormlq,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pdormlqrh,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dgemm_Tile_Async ( PLASMA_enum  transA,
PLASMA_enum  transB,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
double  beta,
PLASMA_desc *  C,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dgemm_Tile_Async - Performs matrix multiplication. Non-blocking equivalent of PLASMA_dgemm_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_dgemm
PLASMA_dgemm_Tile
PLASMA_cgemm_Tile_Async
PLASMA_dgemm_Tile_Async
PLASMA_sgemm_Tile_Async

Definition at line 313 of file dgemm.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_pdgemm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaNoTrans, PlasmaTrans, plasma_request_t::status, and plasma_sequence_t::status.

{
plasma_context_t *plasma;
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_dgemm_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgemm_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgemm_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgemm_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgemm_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descC) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgemm_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if ((transA != PlasmaNoTrans) && (transA != PlasmaTrans) && (transA != PlasmaTrans)) {
plasma_error("PLASMA_dgemm_Tile_Async", "illegal value of transA");
return plasma_request_fail(sequence, request, -1);
}
if ((transB != PlasmaNoTrans) && (transB != PlasmaTrans) && (transB != PlasmaTrans)) {
plasma_error("PLASMA_dgemm_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_dgemm_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_dgemm_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_dgemm_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 == (double)0.0 || K == 0) && beta == (double)1.0))
return PLASMA_SUCCESS;
plasma_parallel_call_9(plasma_pdgemm,
PLASMA_enum, transA,
PLASMA_enum, transB,
double, alpha,
PLASMA_desc, descA,
PLASMA_desc, descB,
double, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dgeqrf_Tile_Async ( PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dgeqrf_Tile_Async - Computes the tile QR factorization of a matrix. Non-blocking equivalent of PLASMA_dgeqrf_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_dgeqrf
PLASMA_dgeqrf_Tile
PLASMA_cgeqrf_Tile_Async
PLASMA_dgeqrf_Tile_Async
PLASMA_sgeqrf_Tile_Async
PLASMA_dgeqrs_Tile_Async

Definition at line 234 of file dgeqrf.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_pdgeqrf(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_error("PLASMA_dgeqrf_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgeqrf_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgeqrf_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgeqrf_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgeqrf_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_dgeqrf_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;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_4(plasma_pdgeqrf,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_5(plasma_pdgeqrfrh,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgeqrs_Tile_Async - Computes a minimum-norm solution using the tile QR factorization. Non-blocking equivalent of PLASMA_dgeqrs_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_dgeqrs
PLASMA_dgeqrs_Tile
PLASMA_cgeqrs_Tile_Async
PLASMA_dgeqrs_Tile_Async
PLASMA_sgeqrs_Tile_Async
PLASMA_dgeqrf_Tile_Async

Definition at line 255 of file dgeqrs.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_pdormqr(), plasma_pdtrsm(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgeqrs_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgeqrs_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgeqrs_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgeqrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgeqrs_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgeqrs_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_dgeqrs_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;
}
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_parallel_call_7(plasma_pdormqr,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_8(plasma_pdormqrrh,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
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);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgesv_incpiv_Tile_Async - Solves a system of linear equations using the tile LU factorization. Non-blocking equivalent of PLASMA_dgesv_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_dgesv_incpiv
PLASMA_dgesv_incpiv_Tile
PLASMA_cgesv_incpiv_Tile_Async
PLASMA_dgesv_incpiv_Tile_Async
PLASMA_sgesv_incpiv_Tile_Async
PLASMA_dcgesv_Tile_Async

Definition at line 252 of file dgesv_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_pdgetrf_incpiv(), plasma_pdtrsm(), plasma_pdtrsmpl(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgesv_incpiv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgesv_incpiv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgesv_incpiv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesv_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descL) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesv_incpiv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesv_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_dgesv_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_parallel_call_5(plasma_pdgetrf_incpiv,
PLASMA_desc, descA,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_6(plasma_pdtrsmpl,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, (double)1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgesv_Tile_Async - Solves a system of linear equations using the tile LU factorization. Non-blocking equivalent of PLASMA_dgesv_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_dgesv
PLASMA_dgesv_Tile
PLASMA_cgesv_Tile_Async
PLASMA_dgesv_Tile_Async
PLASMA_sgesv_Tile_Async
PLASMA_dcgesv_Tile_Async

Definition at line 236 of file dgesv.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_pdtrsm(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgesv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgesv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgesv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesv_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_dgesv_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_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pdgetrf_rectil,
PLASMA_desc, descA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_5(
plasma_pdlaswp,
PLASMA_desc, descB,
int *, IPIV,
int, 1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaLower,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgesvd_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_dgesvd_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_dgesvd
PLASMA_dgesvd_Tile
PLASMA_cgesvd_Tile_Async
PLASMA_dgesvd_Tile_Async
PLASMA_sgesvd_Tile_Async

Definition at line 383 of file dgesvd.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_pdgerbb(), 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;
double *E;
int minMN = min(descA.m, descA.n);
int NCVT = 0;
int NRU = 0;
int NCC = 0;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (jobu != PlasmaNoVec && jobu !=PlasmaVec) {
plasma_error("PLASMA_dgesvd_Tile_Async", "illegal value of jobu");
return PLASMA_ERR_NOT_SUPPORTED;
}
if (jobvt != PlasmaNoVec && jobvt != PlasmaVec) {
plasma_error("PLASMA_dgesvd_Tile_Async", "illegal value of jobvt");
return PLASMA_ERR_NOT_SUPPORTED;
}
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgesvd_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgesvd_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgesvd_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesvd_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_dgesvd_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_dgesvd_Tile_Async", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgesvd_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_dgesvd_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_dgesvd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((jobu == PlasmaVec) || (jobvt == PlasmaVec) ){
plasma_error("PLASMA_dgesvd_Tile_Async", "computing the singular vectors is not supported in this version");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
E = (double *)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_dynamic_call_4(plasma_pdgerbb,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* } */
/* else { */
/* plasma_dynamic_call_4(plasma_pdgerbbrh, */
/* 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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 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_pdorgbr, */
/* PLASMA_enum, PlasmaLeft, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descU, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* else { */
/* plasma_dynamic_call_6(plasma_pdorgbrrh, */
/* 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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 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_pdorgbr, */
/* PLASMA_enum, PlasmaRight, */
/* PLASMA_desc, descA, */
/* PLASMA_desc, descVT, */
/* PLASMA_desc, descT, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* } */
/* else { */
/* plasma_dynamic_call_6(plasma_pdorgbrrh, */
/* 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_pdlaset2,
PLASMA_enum, PlasmaLower,
double, 0.0,
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_pdlaset2,
PLASMA_enum, PlasmaUpper,
double, 0.0,
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_pdgbrdb,
PLASMA_enum, descA.m >= descA.n ? PlasmaUpper : PlasmaLower,
PLASMA_desc, descA,
double*, S,
double*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* Compute the singular values ONLY for now
*/
plasma_dynamic_sync();
if (descA.m >= descA.n)
LAPACKE_dbdsqr(
LAPACK_COL_MAJOR, lapack_const(PlasmaUpper),
minMN, NCVT, NRU, NCC,
S, E,
NULL, 1, NULL, 1, NULL, 1 );
else {
LAPACKE_dbdsqr(
LAPACK_COL_MAJOR, lapack_const(PlasmaLower),
minMN, NCVT, NRU, NCC,
S, E,
NULL, 1, NULL, 1, NULL, 1 );
}
plasma_shared_free(plasma, E);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgetrf_incpiv_Tile_Async - Computes the tile LU factorization of a matrix. Non-blocking equivalent of PLASMA_dgetrf_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_dgetrf_incpiv
PLASMA_dgetrf_incpiv_Tile
PLASMA_cgetrf_incpiv_Tile_Async
PLASMA_dgetrf_incpiv_Tile_Async
PLASMA_sgetrf_incpiv_Tile_Async
PLASMA_dgetrs_incpiv_Tile_Async

Definition at line 232 of file dgetrf_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_pdgetrf_incpiv(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descL = *L;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgetrf_incpiv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgetrf_incpiv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgetrf_incpiv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrf_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descL) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrf_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_dgetrf_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_parallel_call_5(plasma_pdgetrf_incpiv,
PLASMA_desc, descA,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgetrf_Tile_Async - Computes the tile LU factorization of a matrix. Non-blocking equivalent of PLASMA_dgetrf_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_dgetrf
PLASMA_dgetrf_Tile
PLASMA_cgetrf_Tile_Async
PLASMA_dgetrf_Tile_Async
PLASMA_sgetrf_Tile_Async
PLASMA_dgetrs_Tile_Async

Definition at line 237 of file dgetrf.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgetrf_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgetrf_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgetrf_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrf_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_dgetrf_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_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pdgetrf_rectil,
PLASMA_desc, descA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_pnl2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgetri_Tile_Async - Computes the inverse of a matrix using the LU factorization computed by PLASMA_dgetrf. 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_dgetri_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_dgetri
PLASMA_dgetri_Tile
PLASMA_cgetri_Tile_Async
PLASMA_dgetri_Tile_Async
PLASMA_sgetri_Tile_Async
PLASMA_dgetrf_Tile_Async

Definition at line 233 of file dgetri.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_pdtrsmrv(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgetri_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgetri_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgetri_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetri_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_dgetri_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if (max(descA.m, 0) == 0)
return PLASMA_SUCCESS;
plasma_dynamic_call_5(plasma_pdtrtri,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNonUnit,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_9(plasma_pdtrsmrv,
PLASMA_enum, PlasmaRight,
PLASMA_enum, PlasmaLower,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaUnit,
double, (double) 1.0,
PLASMA_desc, descA,
PLASMA_desc, descW,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* No need for barrier tile2row because of previous dependencies */
/* swap */
plasma_dynamic_call_5(
plasma_pdlaswpc,
PLASMA_desc, descA,
int *, IPIV,
int, -1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_row2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgetrs_incpiv_Tile_Async - Solves a system of linear equations using previously computed LU factorization. Non-blocking equivalent of PLASMA_dgetrs_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_dgetrs_incpiv
PLASMA_dgetrs_incpiv_Tile
PLASMA_cgetrs_incpiv_Tile_Async
PLASMA_dgetrs_incpiv_Tile_Async
PLASMA_sgetrs_incpiv_Tile_Async
PLASMA_dgetrf_incpiv_Tile_Async

Definition at line 255 of file dgetrs_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_pdtrsm(), plasma_pdtrsmpl(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgetrs_incpiv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgetrs_incpiv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgetrs_incpiv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrs_incpiv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descL) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrs_incpiv_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrs_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_dgetrs_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_parallel_call_6(plasma_pdtrsmpl,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dgetrs_Tile_Async - Solves a system of linear equations using previously computed LU factorization. Non-blocking equivalent of PLASMA_dgetrs_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_dgetrs
PLASMA_dgetrs_Tile
PLASMA_cgetrs_Tile_Async
PLASMA_dgetrs_Tile_Async
PLASMA_sgetrs_Tile_Async
PLASMA_dgetrf_Tile_Async

Definition at line 248 of file dgetrs.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_pdtrsm(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dgetrs_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dgetrs_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dgetrs_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dgetrs_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_dgetrs_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_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_dynamic_call_5(
plasma_pdlaswp,
PLASMA_desc, descB,
int *, IPIV,
int, 1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaLower,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, trans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(
plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaLower,
PLASMA_enum, trans,
PLASMA_enum, PlasmaUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_dynamic_call_5(
plasma_pdlaswp,
PLASMA_desc, descB,
int *, IPIV,
int, -1,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_pnl2tl,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dlacpy_Tile_Async - Non-blocking equivalent of PLASMA_dlacpy_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_dlacpy
PLASMA_dlacpy_Tile
PLASMA_clacpy_Tile_Async
PLASMA_dlacpy_Tile_Async
PLASMA_slacpy_Tile_Async

Definition at line 227 of file dlacpy.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_pdlacpy(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlacpy_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlacpy_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlacpy_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlacpy_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_dlacpy_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_dlacpy_Tile_Async", "illegal value of uplo");
return -1;
}
/* Quick return */
if (min(descA.m, descA.n) == 0) {
return PLASMA_SUCCESS;
}
plasma_parallel_call_5(plasma_pdlacpy,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dlange_Tile_Async ( PLASMA_enum  norm,
PLASMA_desc *  A,
double *  work,
double *  value,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dlange_Tile_Async - Non-blocking equivalent of PLASMA_dlange_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_dlange
PLASMA_dlange_Tile
PLASMA_clange_Tile_Async
PLASMA_dlange_Tile_Async
PLASMA_slange_Tile_Async

Definition at line 238 of file dlange.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_pdlange(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaMaxNorm, PlasmaOneNorm, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlange_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlange_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlange_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlange_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_dlange_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (norm != PlasmaMaxNorm) && (norm != PlasmaOneNorm)
&& (norm != PlasmaInfNorm) && (norm != PlasmaFrobeniusNorm) ) {
plasma_error("PLASMA_dlange", "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;
return PLASMA_SUCCESS;
}
plasma_parallel_call_6(plasma_pdlange,
PLASMA_enum, norm,
PLASMA_desc, descA,
double*, work,
double*, value,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dlansy_Tile_Async - Non-blocking equivalent of PLASMA_dlansy_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_dlansy
PLASMA_dlansy_Tile
PLASMA_clansy_Tile_Async
PLASMA_dlansy_Tile_Async
PLASMA_slansy_Tile_Async

Definition at line 240 of file dlansy.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_pdlansy(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlansy_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlansy_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlansy_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlansy_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_dlansy_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (norm != PlasmaMaxNorm) && (norm != PlasmaOneNorm)
&& (norm != PlasmaInfNorm) && (norm != PlasmaFrobeniusNorm) ) {
plasma_error("PLASMA_dlansy_Tile", "illegal value of norm");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (uplo != PlasmaUpper) && (uplo != PlasmaLower) ) {
plasma_error("PLASMA_dlansy_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
if ( descA.m == 0) {
*value = 0.0;
return PLASMA_SUCCESS;
}
plasma_parallel_call_7(plasma_pdlansy,
PLASMA_enum, norm,
PLASMA_enum, uplo,
PLASMA_desc, descA,
double*, work,
double*, value,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dLapack_to_Tile_Async ( double *  Af77,
int  LDA,
PLASMA_desc *  A,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dLapack_to_Tile_Async - Conversion from LAPACK layout to tile layout. Non-blocking equivalent of PLASMA_dLapack_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_dTile_to_Lapack_Async
PLASMA_dLapack_to_Tile
PLASMA_cLapack_to_Tile_Async
PLASMA_dLapack_to_Tile_Async
PLASMA_sLapack_to_Tile_Async

Definition at line 128 of file dtile.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_pdlapack_to_tile(), and PLASMA_SUCCESS.

{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dLapack_to_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dLapack_to_Tile", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_parallel_call_5(
plasma_pdlapack_to_tile,
double*, Af77,
int, LDA,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

int PLASMA_dlaset_Tile_Async ( PLASMA_enum  uplo,
double  alpha,
double  beta,
PLASMA_desc *  A,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dlaset_Tile_Async - Non-blocking equivalent of PLASMA_dlaset_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_dlaset
PLASMA_dlaset_Tile
PLASMA_claset_Tile_Async
PLASMA_dlaset_Tile_Async
PLASMA_slaset_Tile_Async

Definition at line 218 of file dlaset.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlaset_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlaset_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlaset_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlaset_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_dlaset_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_dlaset_Tile_Async", "illegal value of uplo");
return -1;
}
/* Quick return */
if (min(descA.m, descA.n) == 0) {
return PLASMA_SUCCESS;
}
plasma_dynamic_call_6(plasma_pdlaset,
PLASMA_enum, uplo,
double, alpha,
double, beta,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dlaswp_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_dlaswp_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_dlaswp
PLASMA_dlaswp_Tile
PLASMA_claswp_Tile_Async
PLASMA_dlaswp_Tile_Async
PLASMA_slaswp_Tile_Async
PLASMA_dgetrf_Tile_Async

Definition at line 226 of file dlaswp.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlaswp_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlaswp_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlaswp_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlaswp_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (K1 != 1) || (K2 != descA.m) ) {
plasma_error("PLASMA_dlaswp_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_dynamic_call_3(
plasma_pdbarrier_tl2pnl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_dynamic_call_5(
plasma_pdlaswp,
PLASMA_desc, descA,
int *, IPIV,
int, INCX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_pnl2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dlaswpc_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_dlaswpc_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_dlaswpc
PLASMA_dlaswpc_Tile
PLASMA_claswpc_Tile_Async
PLASMA_dlaswpc_Tile_Async
PLASMA_slaswpc_Tile_Async
PLASMA_dgetrf_Tile_Async

Definition at line 226 of file dlaswpc.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlaswpc_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlaswpc_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlaswpc_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlaswpc_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (K1 != 1) || (K2 != descA.m) ) {
plasma_error("PLASMA_dlaswpc_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_dynamic_call_3(
plasma_pdbarrier_tl2row,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* swap */
plasma_dynamic_call_5(
plasma_pdlaswpc,
PLASMA_desc, descA,
int *, IPIV,
int, INCX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_3(
plasma_pdbarrier_row2tl,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dlauum_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_dlauum_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_dlauum
PLASMA_dlauum_Tile
PLASMA_clauum_Tile_Async
PLASMA_dlauum_Tile_Async
PLASMA_slauum_Tile_Async
PLASMA_dpotri_Tile_Async

Definition at line 222 of file dlauum.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dlauum_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dlauum_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dlauum_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dlauum_Tile", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb) {
plasma_error("PLASMA_dlauum_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dlauum_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_pdlauum,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dorglq_Tile_Async ( PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_desc *  Q,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

Non-blocking equivalent of PLASMA_dorglq_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_dorglq
PLASMA_dorglq_Tile
PLASMA_cunglq_Tile_Async
PLASMA_dorglq_Tile_Async
PLASMA_sorglq_Tile_Async
PLASMA_dgelqf_Tile_Async

Definition at line 249 of file dorglq.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_dynamic_call_6, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_pdorglq(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, Q, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descQ = *Q;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dorglq_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dorglq_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dorglq_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorglq_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorglq_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descQ) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorglq_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descQ.nb != descQ.mb) {
plasma_error("PLASMA_dorglq_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, Q, LDQ ) */
/*
if (min(M, N) == 0)
return PLASMA_SUCCESS;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_dynamic_call_5(plasma_pdorglq,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_6(plasma_pdorglqrh,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dorgqr_Tile_Async ( PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_desc *  Q,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

Non-blocking equivalent of PLASMA_dorgqr_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_dorgqr
PLASMA_dorgqr_Tile
PLASMA_cungqr_Tile_Async
PLASMA_dorgqr_Tile_Async
PLASMA_sorgqr_Tile_Async
PLASMA_dgeqrf_Tile_Async

Definition at line 247 of file dorgqr.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_dynamic_call_6, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), PLASMA_FLAT_HOUSEHOLDER, plasma_pdorgqr(), plasma_pdorgqrrh(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, Q, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descQ = *Q;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dorgqr_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dorgqr_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dorgqr_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorgqr_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorgqr_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descQ) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dorgqr_Tile", "invalid third descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Check input arguments */
if (descA.nb != descA.mb || descQ.nb != descQ.mb) {
plasma_error("PLASMA_dorgqr_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return */
/*
if (N <= 0)
return PLASMA_SUCCESS;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
plasma_dynamic_call_5(plasma_pdorgqr,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_6(plasma_pdorgqrrh,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dormlq_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  trans,
PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_desc *  B,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

Non-blocking equivalent of PLASMA_dormlq_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_dormlq
PLASMA_dormlq_Tile
PLASMA_cunmlq_Tile_Async
PLASMA_dormlq_Tile_Async
PLASMA_sormlq_Tile_Async
PLASMA_dgelqf_Tile_Async

Definition at line 295 of file dormlq.c.

References A, B, plasma_context_struct::householder, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_7, 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_pdormlq(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaLeft, PlasmaNoTrans, PlasmaRight, PlasmaTrans, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dormlq_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dormlq_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dormlq_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormlq_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormlq_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormlq_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_dormlq_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (side != PlasmaLeft) && (side != PlasmaRight) ) {
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ( (trans != PlasmaTrans) && (trans != PlasmaNoTrans) ){
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, B, LDB ) */
/*
if (min(M, min(N, K)) == 0)
return PLASMA_SUCCESS;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
if ( (trans == PlasmaTrans) &&
(side == PlasmaLeft) ) {
plasma_parallel_call_7(plasma_pdormlq,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
} else {
plasma_dynamic_call_7(plasma_pdormlq,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}
else {
plasma_dynamic_call_8(plasma_pdormlqrh,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dormqr_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  trans,
PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_desc *  B,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

Non-blocking equivalent of PLASMA_dormqr_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_dormqr
PLASMA_dormqr_Tile
PLASMA_cormqr_Tile_Async
PLASMA_dormqr_Tile_Async
PLASMA_sormqr_Tile_Async
PLASMA_dgeqrf_Tile_Async

Definition at line 298 of file dormqr.c.

References A, B, plasma_context_struct::householder, plasma_desc_t::mb, plasma_desc_t::nb, plasma_context_self(), plasma_desc_check(), plasma_dynamic_call_7, 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_pdormqr(), plasma_request_fail(), PLASMA_RHBLK, PLASMA_SUCCESS, PlasmaLeft, PlasmaNoTrans, PlasmaRight, PlasmaTrans, plasma_request_t::status, plasma_sequence_t::status, and T.

{
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dormqr_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dormqr_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dormqr_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormqr_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormqr_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dormqr_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_dormqr_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if ((trans != PlasmaTrans) && (trans != PlasmaNoTrans)){
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
/* Quick return - currently NOT equivalent to LAPACK's:
* CALL DLASET( 'Full', MAX( M, N ), NRHS, ZERO, ZERO, B, LDB ) */
/*
if (min(M, min(N, K)) == 0)
return PLASMA_SUCCESS;
*/
if (plasma->householder == PLASMA_FLAT_HOUSEHOLDER) {
if ( (trans == PlasmaTrans) &&
(side == PlasmaLeft) ) {
plasma_parallel_call_7(plasma_pdormqr,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
else {
plasma_dynamic_call_7(plasma_pdormqr,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
}
else {
plasma_dynamic_call_8(plasma_pdormqrrh,
PLASMA_enum, side,
PLASMA_enum, trans,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descT,
PLASMA_enum, PLASMA_RHBLK,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dplgsy_Tile_Async ( double  bump,
PLASMA_desc *  A,
unsigned long long int  seed,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dplgsy_Tile_Async - Generate a random hermitian matrix by tiles. Non-blocking equivalent of PLASMA_dplgsy_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_dplgsy
PLASMA_dplgsy_Tile
PLASMA_cplgsy_Tile_Async
PLASMA_dplgsy_Tile_Async
PLASMA_splgsy_Tile_Async
PLASMA_dplgsy_Tile_Async
PLASMA_dplgsy_Tile_Async

Definition at line 203 of file dplgsy.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_pdplgsy(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dplrnt_Tile_Async - Generate a random matrix by tiles. Non-blocking equivalent of PLASMA_dplrnt_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_dplrnt
PLASMA_dplrnt_Tile
PLASMA_cplrnt_Tile_Async
PLASMA_dplrnt_Tile_Async
PLASMA_splrnt_Tile_Async
PLASMA_dplgsy_Tile_Async
PLASMA_dplgsy_Tile_Async

Definition at line 201 of file dplrnt.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_pdplrnt(), plasma_request_fail(), PLASMA_SUCCESS, plasma_request_t::status, and plasma_sequence_t::status.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dposv_Tile_Async - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization. Non-blocking equivalent of PLASMA_dposv_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_dposv
PLASMA_dposv_Tile
PLASMA_cposv_Tile_Async
PLASMA_dposv_Tile_Async
PLASMA_sposv_Tile_Async

Definition at line 260 of file dposv.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_pdpotrf(), plasma_pdtrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dposv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dposv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dposv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dposv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dposv_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_dposv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dposv_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_parallel_call_4(plasma_pdpotrf,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaTrans : PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dpotrf_Tile_Async - Computes the Cholesky factorization of a symmetric positive definite or Hermitian positive definite matrix. Non-blocking equivalent of PLASMA_dpotrf_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_dpotrf
PLASMA_dpotrf_Tile
PLASMA_cpotrf_Tile_Async
PLASMA_dpotrf_Tile_Async
PLASMA_spotrf_Tile_Async
PLASMA_dpotrs_Tile_Async

Definition at line 232 of file dpotrf.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_pdpotrf(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dpotri_Tile_Async - Computes the inverse of a complex Hermitian positive definite matrix A using the Cholesky factorization A = U**T*U or A = L*L**T computed by PLASMA_dpotrf. Non-blocking equivalent of PLASMA_dpotri_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_dpotri
PLASMA_dpotri_Tile
PLASMA_cpotri_Tile_Async
PLASMA_dpotri_Tile_Async
PLASMA_spotri_Tile_Async
PLASMA_dpotrf_Tile_Async

Definition at line 222 of file dpotri.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dpotri_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dpotri_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dpotri_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dpotri_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_dpotri_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dpotri_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_pdtrtri,
PLASMA_enum, uplo,
PLASMA_enum, PlasmaNonUnit,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_pdlauum,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dpotrs_Tile_Async - Solves a system of linear equations using previously computed Cholesky factorization. Non-blocking equivalent of PLASMA_dpotrs_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_dpotrs
PLASMA_dpotrs_Tile
PLASMA_cpotrs_Tile_Async
PLASMA_dpotrs_Tile_Async
PLASMA_spotrs_Tile_Async
PLASMA_dpotrf_Tile_Async

Definition at line 236 of file dpotrs.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_pdtrsm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dpotrs_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dpotrs_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dpotrs_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dpotrs_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dpotrs_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_dpotrs_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dpotrs_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
/* Quick return */
/*
if (min(N, NRHS) == 0)
return PLASMA_SUCCESS;
*/
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaTrans : PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsgesv_Tile_Async ( PLASMA_desc *  A,
int *  IPIV,
PLASMA_desc *  B,
PLASMA_desc *  X,
int *  ITER,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsgesv_Tile_Async - Solves a system of linear equations using the tile LU factorization and mixed-precision iterative refinement. Non-blocking equivalent of PLASMA_dsgesv_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_dsgesv
PLASMA_dsgesv_Tile
PLASMA_dsgesv_Tile_Async
PLASMA_dgesv_Tile_Async

Definition at line 424 of file dsgesv.c.

References A, B, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_ddesc_alloc, plasma_desc_check(), plasma_desc_mat_free(), PLASMA_dgeadd, PLASMA_dgetrs, PLASMA_dlacpy, PLASMA_dlag2s, PLASMA_dlange, plasma_dynamic_call_3, plasma_dynamic_call_4, plasma_dynamic_sync, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_OUT_OF_RESOURCES, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_memzero(), plasma_parallel_call_9, plasma_pdgemm(), plasma_request_fail(), plasma_sdesc_alloc, PLASMA_sgetrs, plasma_shared_alloc(), plasma_shared_free(), PLASMA_SIZE, PLASMA_slag2d, PLASMA_SUCCESS, PlasmaInfNorm, PlasmaInteger, PlasmaMaxNorm, PlasmaNoTrans, PlasmaRealDouble, plasma_request_t::status, and plasma_sequence_t::status.

{
int N, NB;
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descX = *X;
PLASMA_desc descR, descSA, descSX;
plasma_context_t *plasma;
double *work;
const int itermax = 30;
const double bwdmax = 1.0;
const double negone = -1.0;
const double one = 1.0;
int iiter;
double Anorm, cte, eps, Rnorm, Xnorm;
*ITER=0;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsgesv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsgesv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsgesv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsgesv_Tile", "invalid first descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsgesv_Tile", "invalid third descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descX) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsgesv_Tile", "invalid fourth descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb || descX.nb != descX.mb) {
plasma_error("PLASMA_dsgesv_Tile", "only square tiles supported");
return PLASMA_ERR_ILLEGAL_VALUE;
}
/* Set N, NRHS, NT */
N = descA.m;
NB = descA.nb;
work = (double *)plasma_shared_alloc(plasma, PLASMA_SIZE, PlasmaRealDouble);
if (work == NULL) {
plasma_error("PLASMA_dsgesv", "plasma_shared_alloc() failed");
plasma_shared_free(plasma, work);
return PLASMA_ERR_OUT_OF_RESOURCES;
}
plasma_ddesc_alloc( descR, NB, NB, descB.m, descB.n, 0, 0, descB.m, descB.n,
plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR) );
plasma_sdesc_alloc( descSA, NB, NB, descA.m, descA.n, 0, 0, descA.m, descA.n,
plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR);
plasma_desc_mat_free(&descSA) );
plasma_sdesc_alloc( descSX, NB, NB, descX.m, descX.n, 0, 0, descX.m, descX.n,
plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR);
plasma_desc_mat_free(&descSA); plasma_desc_mat_free(&descSX) );
/* Compute some constants */
PLASMA_dlange(PlasmaInfNorm, descA, Anorm, work);
eps = LAPACKE_dlamch_work('e');
/* Convert B from double precision to single precision and store
the result in SX. */
PLASMA_dlag2s(descB, descSX);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Convert A from double precision to single precision and store
the result in SA. */
PLASMA_dlag2s(descA, descSA);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Clear IPIV and Lbdl */
plasma_memzero(IPIV, N, PlasmaInteger);
/* Compute the LU factorization of SA */
plasma_dynamic_call_3(
plasma_psbarrier_tl2pnl,
PLASMA_desc, descSA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_dynamic_call_4(plasma_psgetrf_rectil,
PLASMA_desc, descSA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Solve the system SA*SX = SB */
PLASMA_sgetrs(descSA, IPIV, descSX);
/* Convert SX back to double precision */
PLASMA_slag2d(descSX, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB, descR);
plasma_parallel_call_9(plasma_pdgemm,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNoTrans,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward error satisfies the
stopping criterion. If yes return. Note that ITER=0 (already set). */
PLASMA_dlange(PlasmaMaxNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaMaxNorm, descR, Rnorm, work);
/* Wait the end of Anorm, Xnorm and Bnorm computations */
plasma_dynamic_sync();
cte = Anorm*eps*sqrt((double) N)*bwdmax;
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
/* Iterative refinement */
for (iiter = 0; iiter < itermax; iiter++){
/* Convert R from double precision to single precision
and store the result in SX. */
PLASMA_dlag2s(descR, descSX);
/* Solve the system SA*SX = SB */
PLASMA_sgetrs(descSA, IPIV, descSX);
/* Convert SX back to double precision and update the current
iterate. */
PLASMA_slag2d(descSX, descR);
PLASMA_dgeadd(one, descR, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB,descR);
plasma_parallel_call_9(plasma_pdgemm,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNoTrans,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward errors satisfy the
stopping criterion. If yes, set ITER=IITER>0 and return. */
PLASMA_dlange(PlasmaInfNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaInfNorm, descR, Rnorm, work);
/* Wait the end of Xnorm and Bnorm computations */
plasma_dynamic_sync();
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
*ITER = iiter;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
}
/* We have performed ITER=itermax iterations and never satisified
the stopping criterion, set up the ITER flag accordingly and
follow up on double precision routine. */
*ITER = -itermax - 1;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
/* Single-precision iterative refinement failed to converge to a
satisfactory solution, so we resort to double precision. */
/* Clear IPIV and Lbdl */
plasma_memzero(IPIV, N, PlasmaInteger);
plasma_dynamic_call_4(plasma_pdgetrf_rectil,
PLASMA_desc, descA,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_dlacpy(descB, descX);
PLASMA_dgetrs(descA, IPIV, descX);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsposv_Tile_Async ( PLASMA_enum  uplo,
PLASMA_desc *  A,
PLASMA_desc *  B,
PLASMA_desc *  X,
int *  ITER,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsposv_Tile_Async - Solves a symmetric positive definite or Hermitian positive definite system of linear equations using the Cholesky factorization and mixed-precision iterative refinement. Non-blocking equivalent of PLASMA_dsposv_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_dsposv
PLASMA_dsposv_Tile
PLASMA_dsposv_Tile_Async
PLASMA_dposv_Tile_Async

Definition at line 374 of file dsposv.c.

References A, B, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_ddesc_alloc, plasma_desc_check(), plasma_desc_mat_free(), PLASMA_dgeadd, PLASMA_dlacpy, PLASMA_dlag2s, PLASMA_dlange, PLASMA_dlansy, plasma_dynamic_sync, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_OUT_OF_RESOURCES, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_parallel_call_9, plasma_pdpotrf(), plasma_pdsymm(), plasma_pdtrsm(), plasma_pspotrf(), plasma_pstrsm(), plasma_request_fail(), plasma_sdesc_alloc, plasma_shared_alloc(), plasma_shared_free(), PLASMA_SIZE, PLASMA_slag2d, PLASMA_SUCCESS, PlasmaInfNorm, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaRealDouble, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
int N, NB;
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descX = *X;
plasma_context_t *plasma;
double *work;
PLASMA_desc descR, descSA, descSX;
const int itermax = 30;
const double bwdmax = 1.0;
const double negone = -1.0;
const double one = 1.0;
int iiter;
double Anorm, cte, eps, Rnorm, Xnorm;
*ITER=0;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsposv_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsposv_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsposv_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsposv_Tile_Async", "invalid first descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsposv_Tile_Async", "invalid second descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descX) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsposv_Tile_Async", "invalid third descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
/* Check input arguments */
if (descA.nb != descA.mb || descB.nb != descB.mb || descX.nb != descX.mb) {
plasma_error("PLASMA_dsposv_Tile_Async", "only square tiles supported");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dsposv_Tile_Async", "illegal value of uplo");
return -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;
*/
/* Set N, NRHS */
N = descA.m;
NB = descA.nb;
work = (double *)plasma_shared_alloc(plasma, PLASMA_SIZE, PlasmaRealDouble);
if (work == NULL) {
plasma_error("PLASMA_dsposv_Tile_Async", "plasma_shared_alloc() failed");
plasma_shared_free(plasma, work);
return PLASMA_ERR_OUT_OF_RESOURCES;
}
plasma_ddesc_alloc( descR, NB, NB, descB.m, descB.n, 0, 0, descB.m, descB.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR) );
plasma_sdesc_alloc( descSA, NB, NB, descA.m, descA.n, 0, 0, descA.m, descA.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR); plasma_desc_mat_free(&descSA) );
plasma_sdesc_alloc( descSX, NB, NB, descX.m, descX.n, 0, 0, descX.m, descX.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR); plasma_desc_mat_free(&descSA); plasma_desc_mat_free(&descSX) );
/* Compute some constants */
PLASMA_dlansy(PlasmaInfNorm, uplo, descA, Anorm, work);
eps = LAPACKE_dlamch_work('e');
/* Convert B from double precision to single precision and store
the result in SX. */
PLASMA_dlag2s(descB, descSX);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Convert A from double precision to single precision and store
the result in SA. */
PLASMA_dlag2s(descA, descSA);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Compute the Cholesky factorization of SA */
plasma_parallel_call_4(plasma_pspotrf,
PLASMA_enum, uplo,
PLASMA_desc, descSA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Solve the system SA*SX = SB */
/* Forward substitution */
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaTrans : PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
float, 1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Backward substitution */
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaTrans,
PLASMA_enum, PlasmaNonUnit,
float, 1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Convert SX back to double precision */
PLASMA_slag2d(descSX, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB,descR);
plasma_parallel_call_9(plasma_pdsymm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward error satisfies the
stopping criterion. If yes return. Note that ITER=0 (already set). */
PLASMA_dlange(PlasmaInfNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaInfNorm, descR, Rnorm, work);
/* Wait the end of Anorm, Xnorm and Bnorm computations */
plasma_dynamic_sync();
cte = Anorm*eps*((double) N)*bwdmax;
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
/* Iterative refinement */
for (iiter = 0; iiter < itermax; iiter++){
/* Convert R from double precision to single precision
and store the result in SX. */
PLASMA_dlag2s(descR, descSX);
/* Solve the system SA*SX = SR */
/* Forward substitution */
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaTrans : PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
float, 1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Backward substitution */
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaTrans,
PLASMA_enum, PlasmaNonUnit,
float, 1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Convert SX back to double precision and update the current
iterate. */
PLASMA_slag2d(descSX, descR);
PLASMA_dgeadd(one, descR, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB,descR);
plasma_parallel_call_9(plasma_pdsymm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward errors satisfy the
stopping criterion. If yes, set ITER=IITER>0 and return. */
PLASMA_dlange(PlasmaInfNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaInfNorm, descR, Rnorm, work);
/* Wait the end of Xnorm and Bnorm computations */
plasma_dynamic_sync();
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
*ITER = iiter;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
}
/* We have performed ITER=itermax iterations and never satisified
the stopping criterion, set up the ITER flag accordingly and
follow up on double precision routine. */
*ITER = -itermax - 1;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
/* Single-precision iterative refinement failed to converge to a
satisfactory solution, so we resort to double precision. */
plasma_parallel_call_4(plasma_pdpotrf,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
PLASMA_dlacpy(descB,descX);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaTrans : PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, uplo,
PLASMA_enum, uplo == PlasmaUpper ? PlasmaNoTrans : PlasmaTrans,
PLASMA_enum, PlasmaNonUnit,
double, 1.0,
PLASMA_desc, descA,
PLASMA_desc, descX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsungesv_Tile_Async ( PLASMA_enum  trans,
PLASMA_desc *  A,
PLASMA_desc *  T,
PLASMA_desc *  B,
PLASMA_desc *  X,
int *  ITER,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsungesv_Tile_Async - Solves symmetric linear system of equations using the tile QR or the tile LQ factorization and mixed-precision iterative refinement. Non-blocking equivalent of PLASMA_dsungesv_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_dsungesv
PLASMA_dsungesv_Tile
PLASMA_dsungesv_Tile_Async
PLASMA_dgels_Tile_Async

Definition at line 378 of file dsungesv.c.

References A, B, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::n, plasma_desc_t::nb, plasma_context_self(), plasma_ddesc_alloc, plasma_desc_check(), plasma_desc_mat_free(), PLASMA_dgeadd, PLASMA_dlacpy, PLASMA_dlag2s, PLASMA_dlange, plasma_dynamic_sync, PLASMA_ERR_ILLEGAL_VALUE, PLASMA_ERR_NOT_INITIALIZED, PLASMA_ERR_NOT_SUPPORTED, PLASMA_ERR_OUT_OF_RESOURCES, PLASMA_ERR_SEQUENCE_FLUSHED, PLASMA_ERR_UNALLOCATED, plasma_error(), plasma_fatal_error(), plasma_parallel_call_4, plasma_parallel_call_7, plasma_parallel_call_9, plasma_pdgemm(), plasma_pdgeqrf(), plasma_pdormqr(), plasma_pdtrsm(), plasma_psgeqrf(), plasma_psormqr(), plasma_pstrsm(), plasma_request_fail(), plasma_sdesc_alloc, plasma_shared_alloc(), plasma_shared_free(), PLASMA_SIZE, PLASMA_slag2d, PLASMA_SUCCESS, PlasmaInfNorm, PlasmaLeft, PlasmaNonUnit, PlasmaNoTrans, PlasmaRealDouble, PlasmaTrans, PlasmaUpper, plasma_request_t::status, plasma_sequence_t::status, and T.

{
int N, NB, IB;
PLASMA_desc descA = *A;
PLASMA_desc descT = *T;
PLASMA_desc descB = *B;
PLASMA_desc descX = *X;
PLASMA_desc descR, descSA, descST, descSX;
plasma_context_t *plasma;
double *work;
const int itermax = 30;
const double bwdmax = 1.0;
const double negone = -1.0;
const double one = 1.0;
int iiter;
double Anorm, cte, eps, Rnorm, Xnorm;
*ITER=0;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsungesv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsungesv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsungesv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsungesv_Tile", "invalid first descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsungesv_Tile", "invalid second descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsungesv_Tile", "invalid third descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (plasma_desc_check(&descX) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsungesv_Tile", "invalid fourth descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
/* Check input arguments */
if ( (descA.nb != descA.mb) || (descB.nb != descB.mb) || (descX.nb != descX.mb) ||
(descA.mb != descB.mb) || (descB.mb != descX.mb) ) {
plasma_error("PLASMA_dsungesv_Tile", "only square tiles of same size are supported");
return PLASMA_ERR_ILLEGAL_VALUE;
}
if (trans != PlasmaNoTrans) {
plasma_error("PLASMA_dsungesv_Tile", "only PlasmaNoTrans supported");
return PLASMA_ERR_NOT_SUPPORTED;
}
/* Set N, NRHS, NB */
N = descA.m;
NB = descA.nb;
IB = descT.mb;
work = (double *)plasma_shared_alloc(plasma, PLASMA_SIZE, PlasmaRealDouble);
if (work == NULL) {
plasma_error("PLASMA_dsungesv", "plasma_shared_alloc() failed");
plasma_shared_free(plasma, work);
return PLASMA_ERR_OUT_OF_RESOURCES;
}
plasma_ddesc_alloc( descR, NB, NB, descB.m, descB.n, 0, 0, descB.m, descB.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR) );
plasma_sdesc_alloc( descSA, NB, NB, descA.m, descA.n, 0, 0, descA.m, descA.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR); plasma_desc_mat_free(&descSA) );
plasma_sdesc_alloc( descST, IB, NB, descT.m, descT.n, 0, 0, descT.m, descT.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR); plasma_desc_mat_free(&descSA); plasma_desc_mat_free(&descST) );
plasma_sdesc_alloc( descSX, NB, NB, descX.m, descX.n, 0, 0, descX.m, descX.n, plasma_shared_free( plasma, work ); plasma_desc_mat_free(&descR); plasma_desc_mat_free(&descSA); plasma_desc_mat_free(&descST); plasma_desc_mat_free(&descSX) );
/* Compute some constants */
PLASMA_dlange(PlasmaInfNorm, descA, Anorm, work);
eps = LAPACKE_dlamch_work('e');
/* Convert B from double precision to single precision and store
the result in SX. */
PLASMA_dlag2s(descB, descSX);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Convert A from double precision to single precision and store
the result in SA. */
PLASMA_dlag2s(descA, descSA);
if (sequence->status != PLASMA_SUCCESS)
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Compute the QR factorization of SA */
plasma_parallel_call_4(plasma_psgeqrf,
PLASMA_desc, descSA,
PLASMA_desc, descST,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Compute the solve in simple */
plasma_parallel_call_7(plasma_psormqr,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_desc, descST,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
float, 1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Convert SX back to double precision */
PLASMA_slag2d(descSX, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB, descR);
plasma_parallel_call_9(plasma_pdgemm,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNoTrans,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward error satisfies the
stopping criterion. If yes return. Note that ITER=0 (already set). */
PLASMA_dlange(PlasmaInfNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaInfNorm, descR, Rnorm, work);
/* Wait the end of Anorm, Xnorm and Bnorm computations */
plasma_dynamic_sync();
cte = Anorm*eps*((double) N)*bwdmax;
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descST);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
/* Iterative refinement */
for (iiter = 0; iiter < itermax; iiter++){
/* Convert R from double precision to single precision
and store the result in SX. */
PLASMA_dlag2s(descR, descSX);
plasma_parallel_call_7(plasma_psormqr,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_desc, descST,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pstrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
float, (float)1.0,
PLASMA_desc, descSA,
PLASMA_desc, descSX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Convert SX back to double precision and update the current
iterate. */
PLASMA_slag2d(descSX, descR);
PLASMA_dgeadd(one, descR, descX);
/* Compute R = B - AX. */
PLASMA_dlacpy(descB,descR);
plasma_parallel_call_9(plasma_pdgemm,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNoTrans,
double, negone,
PLASMA_desc, descA,
PLASMA_desc, descX,
double, one,
PLASMA_desc, descR,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* Check whether the NRHS normwise backward errors satisfy the
stopping criterion. If yes, set ITER=IITER>0 and return. */
PLASMA_dlange(PlasmaInfNorm, descX, Xnorm, work);
PLASMA_dlange(PlasmaInfNorm, descR, Rnorm, work);
/* Wait the end of Xnorm and Bnorm computations */
plasma_dynamic_sync();
if (Rnorm < Xnorm * cte){
/* The NRHS normwise backward errors satisfy the
stopping criterion. We are good to exit. */
*ITER = iiter;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descST);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
return PLASMA_SUCCESS;
}
}
/* We have performed ITER=itermax iterations and never satisified
the stopping criterion, set up the ITER flag accordingly and
follow up on double precision routine. */
*ITER = -itermax - 1;
plasma_desc_mat_free(&descSA);
plasma_desc_mat_free(&descST);
plasma_desc_mat_free(&descSX);
plasma_desc_mat_free(&descR);
plasma_shared_free(plasma, work);
/* Single-precision iterative refinement failed to converge to a
satisfactory solution, so we restart to double precision. */
PLASMA_dlacpy(descB, descX);
plasma_parallel_call_4(plasma_pdgeqrf,
PLASMA_desc, descA,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_7(plasma_pdormqr,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaTrans,
PLASMA_desc, descA,
PLASMA_desc, descX,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, PlasmaLeft,
PLASMA_enum, PlasmaUpper,
PLASMA_enum, PlasmaNoTrans,
PLASMA_enum, PlasmaNonUnit,
double, (double)1.0,
PLASMA_desc, descA,
PLASMA_desc, descX,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dsyev_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_dsyev
PLASMA_dsyev_Tile
PLASMA_cheev_Tile_Async
PLASMA_dsyev_Tile_Async
PLASMA_ssyev_Tile_Async

Definition at line 326 of file dsyev.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;
double *E;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsyev_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsyev_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsyev_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyev_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyev_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec){
if (plasma_desc_check(Q) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyev_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_dsyev_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaLower && uplo != PlasmaUpper) {
plasma_error("PLASMA_dsyev_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.m != descA.n) {
plasma_error("PLASMA_dsyev_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_dsyev_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_dsyev_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_dsyev_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
}
E = (double *)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_pdsyrbt,
PLASMA_enum, uplo,
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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pdorgtr, */
/* 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_pdlaset2,
PLASMA_enum, uplo,
double, 0.0,
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_pdsbrdt,
PLASMA_enum, uplo,
PLASMA_desc, descA,
double*, W,
double*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/*
* For eigenvalues only, call DSTERF.
* For eigenvectors, first call DORGTR to generate the unitary matrix,
* then call ZSTEQR.
*/
plasma_dynamic_sync();
if (jobz == PlasmaNoVec){
LAPACKE_dsterf(descA.n, W, E);
}else {
LAPACKE_dsterf(descA.n, W, E);
/* Accumulate the transformations from the second stage */
/*
plasma_dynamic_call_6(plasma_pdorgtr,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
LAPACKE_dsteqr(jobz, descA.n, W, E, Q->mat, Q->lm);
*/
}
/* If matrix was scaled, then rescale eigenvalues appropriately.
*/
plasma_shared_free(plasma, E);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dsygst_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**T)*A*inv(U) or inv(L)*A*inv(L**T) 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**T or L**T*A*L. B must have been previously factorized as U**T*U or L*L**T by PLASMA_DPOTRF. ONLY PlasmaItype == 1 and PlasmaLower supported! Non-blocking equivalent of PLASMA_dsygst_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_dsygst
PLASMA_dsygst_Tile
PLASMA_chegst_Tile_Async
PLASMA_dsygst_Tile_Async
PLASMA_ssygst_Tile_Async
PLASMA_dsygv_Tile_Async

Definition at line 291 of file dsygst.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsygst_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsygst_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsygst_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygst_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygst_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_dsygst_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_pdsygst,
PLASMA_enum, itype,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dsygv_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_dsygv_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_dsygv
PLASMA_dsygv_Tile
PLASMA_chegv_Tile_Async
PLASMA_dsygv_Tile_Async
PLASMA_ssygv_Tile_Async

Definition at line 424 of file dsygv.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_pdpotrf(), 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;
double *E;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsygv_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsygv_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsygv_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygv_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygv_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygv_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec){
if (plasma_desc_check(Q) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsygv_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_dsygv_Tile_Async", "Illegal value of itype");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz != PlasmaNoVec && jobz != PlasmaVec) {
plasma_error("PLASMA_dsygv_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (uplo != PlasmaLower && uplo != PlasmaUpper) {
plasma_error("PLASMA_dsyev_Tile_Async", "illegal value of uplo");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.nb != descA.mb) {
plasma_error("PLASMA_dsygv_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_dsygv_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_dsygv_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
E = (double *)plasma_shared_alloc(plasma, descA.n-1, PlasmaRealDouble);
/* Currently NOT equivalent to LAPACK's
*/
plasma_parallel_call_4(plasma_pdpotrf,
PLASMA_enum, uplo,
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_pdsygst,
PLASMA_enum, itype,
PLASMA_enum, uplo,
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_pdsyrbt,
PLASMA_enum, uplo,
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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage *\/ */
/* plasma_dynamic_call_6(plasma_pdorgtr, */
/* 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_pdlaset2,
PLASMA_enum, uplo,
double, 0.0,
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_pdsbrdt,
PLASMA_enum, uplo,
PLASMA_desc, descA,
double*, W,
double*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
/* For eigenvalues only, call DSTERF.
* For eigenvectors, first call DORGTR to generate the unitary matrix,
* then call ZSTEQR.
*/
if (jobz == PlasmaNoVec)
status = LAPACKE_dsterf(descA.n, W, E);
else {
status = LAPACKE_dsterf(descA.n, W, E);
/* Accumulate the transformations from the second stage */
/*
plasma_dynamic_call_6(plasma_pdorgtr,
PLASMA_enum, uplo,
PLASMA_desc, descA,
PLASMA_desc, descQ,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
LAPACKE_dsteqr(jobz, descA.n, W, E, descQ.mat, descQ.lm);
*/
}
/* If matrix was scaled, then rescale eigenvalues appropriately.
*/
plasma_shared_free(plasma, E);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsymm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
double  beta,
PLASMA_desc *  C,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsymm_Tile_Async - Performs symmetric matrix multiplication. Non-blocking equivalent of PLASMA_dsymm_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_dsymm
PLASMA_dsymm_Tile
PLASMA_csymm_Tile_Async
PLASMA_dsymm_Tile_Async
PLASMA_ssymm_Tile_Async

Definition at line 303 of file dsymm.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_pdsymm(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLeft, PlasmaLower, PlasmaRight, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
plasma_context_t *plasma;
PLASMA_desc descA = *A;
PLASMA_desc descB = *B;
PLASMA_desc descC = *C;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsymm_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsymm_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsymm_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsymm_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsymm_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descC) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsymm_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_dsymm_Tile_Async", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if ((uplo != PlasmaLower) && (uplo != PlasmaUpper)) {
plasma_error("PLASMA_dsymm_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_dsymm_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_dsymm_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_dsymm_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_dsymm_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_dsymm_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_dsymm_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_dsymm_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 == (double)0.0) && (beta == (double)1.0) ))
return PLASMA_SUCCESS;
plasma_parallel_call_9(plasma_pdsymm,
PLASMA_enum, side,
PLASMA_enum, uplo,
double, alpha,
PLASMA_desc, descA,
PLASMA_desc, descB,
double, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsyr2k_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
double  beta,
PLASMA_desc *  C,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsyr2k_Tile_Async - Performs symmetric rank-k update. Non-blocking equivalent of PLASMA_dsyr2k_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_dsyr2k
PLASMA_dsyr2k_Tile
PLASMA_csyr2k_Tile_Async
PLASMA_dsyr2k_Tile_Async
PLASMA_ssyr2k_Tile_Async

Definition at line 299 of file dsyr2k.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_pdsyr2k(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
plasma_context_t *plasma;
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_dsyr2k_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsyr2k_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsyr2k_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyr2k_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyr2k_Tile_Async", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descC) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyr2k_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_dsyr2k", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
plasma_error("PLASMA_dsyr2k", "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_dsyr2k_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_dsyr2k_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_dsyr2k_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_dsyr2k_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 == (double)0.0 || K == 0) && beta == (double)1.0))
return PLASMA_SUCCESS;
plasma_parallel_call_9(plasma_pdsyr2k,
PLASMA_enum, uplo,
PLASMA_enum, trans,
double, alpha,
PLASMA_desc, descA,
PLASMA_desc, descB,
double, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dsyrk_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  trans,
double  alpha,
PLASMA_desc *  A,
double  beta,
PLASMA_desc *  C,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dsyrk_Tile_Async - Performs rank-k update. Non-blocking equivalent of PLASMA_dsyrk_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_dsyrk
PLASMA_dsyrk_Tile
PLASMA_csyrk_Tile_Async
PLASMA_dsyrk_Tile_Async
PLASMA_ssyrk_Tile_Async

Definition at line 276 of file dsyrk.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_pdsyrk(), plasma_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

{
plasma_context_t *plasma;
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_dsyrk_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsyrk_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsyrk_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyrk_Tile_Async", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descC) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsyrk_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_dsyrk", "illegal value of uplo");
return plasma_request_fail(sequence, request, -1);
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
plasma_error("PLASMA_dsyrk", "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_dsyrk_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (Amb != descC.mb) {
plasma_error("PLASMA_dsyrk_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_dsyrk_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_dsyrk_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 == (double)0.0 || K == 0) && beta == (double)1.0))
return PLASMA_SUCCESS;
plasma_parallel_call_8(plasma_pdsyrk,
PLASMA_enum, uplo,
PLASMA_enum, trans,
double, alpha,
PLASMA_desc, descA,
double, beta,
PLASMA_desc, descC,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dsytrd_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_dsytrd
PLASMA_dsytrd_Tile
PLASMA_chetrd_Tile_Async
PLASMA_dsytrd_Tile_Async
PLASMA_ssytrd_Tile_Async

Definition at line 331 of file dsytrd.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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dsytrd_Tile_Async", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dsytrd_Tile_Async", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dsytrd_Tile_Async", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsytrd_Tile_Async", "invalid descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descT) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dsytrd_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_dsytrd_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_dsytrd_Tile_Async", "illegal value of jobz");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (descA.m != descA.n) {
plasma_error("PLASMA_dsytrd_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_dsytrd_Tile_Async", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (jobz == PlasmaVec) {
plasma_error("PLASMA_dsytrd_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_dsytrd_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_pdsyrbt,
PLASMA_enum, uplo,
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_pdlaset, */
/* PLASMA_enum, PlasmaUpperLower, */
/* double, 0.0, */
/* double, 1.0, */
/* PLASMA_desc, descQ, */
/* PLASMA_sequence*, sequence, */
/* PLASMA_request*, request); */
/* /\* Accumulate the transformations from the first stage*\/ */
/* plasma_dynamic_call_6(plasma_pdorgtr, */
/* 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_pdlaset2,
PLASMA_enum, uplo,
double, 0.0,
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_pdsbrdt,
PLASMA_enum, uplo,
PLASMA_desc, descA,
double*, D,
double*, E,
PLASMA_desc, descT,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dTile_to_Lapack_Async ( PLASMA_desc *  A,
double *  Af77,
int  LDA,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dTile_to_Lapack_Async - Conversion from LAPACK layout to tile layout. Non-blocking equivalent of PLASMA_dTile_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_dLapack_to_Tile_Async
PLASMA_dTile_to_Lapack
PLASMA_cTile_to_Lapack_Async
PLASMA_dTile_to_Lapack_Async
PLASMA_sTile_to_Lapack_Async

Definition at line 264 of file dtile.c.

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

{
PLASMA_desc descA = *A;
plasma_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dTile_to_Lapack", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
/* Check descriptor for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dTile_to_Lapack", "invalid descriptor");
return PLASMA_ERR_ILLEGAL_VALUE;
}
plasma_static_call_5(
plasma_pdtile_to_lapack,
PLASMA_desc, descA,
double*, Af77,
int, LDA,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

int PLASMA_dtrmm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dtrmm_Tile_Async - Performs triangular matrix multiplication. Non-blocking equivalent of PLASMA_dtrmm_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_dtrmm
PLASMA_dtrmm_Tile
PLASMA_ctrmm_Tile_Async
PLASMA_dtrmm_Tile_Async
PLASMA_strmm_Tile_Async

Definition at line 298 of file dtrmm.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_pdtrmm(), plasma_request_fail(), PLASMA_SUCCESS, 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dtrmm_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dtrmm_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dtrmm_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrmm_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrmm_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_dtrmm_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_dtrmm_Tile", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dtrmm_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
if (transA != PlasmaTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
plasma_error("PLASMA_dtrmm_Tile", "illegal value of transA");
return plasma_request_fail(sequence, request, -3);
}
if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
plasma_error("PLASMA_dtrmm_Tile", "illegal value of diag");
return plasma_request_fail(sequence, request, -4);
}
/* Quick return */
plasma_dynamic_call_9(plasma_pdtrmm,
PLASMA_enum, side,
PLASMA_enum, uplo,
PLASMA_enum, transA,
PLASMA_enum, diag,
double, alpha,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dtrsm_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dtrsm_Tile_Async - Computes triangular solve. Non-blocking equivalent of PLASMA_dtrsm_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_dtrsm
PLASMA_dtrsm_Tile
PLASMA_ctrsm_Tile_Async
PLASMA_dtrsm_Tile_Async
PLASMA_strsm_Tile_Async

Definition at line 298 of file dtrsm.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_pdtrsm(), plasma_request_fail(), PLASMA_SUCCESS, 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dtrsm_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dtrsm_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dtrsm_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsm_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsm_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_dtrsm_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_dtrsm_Tile", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dtrsm_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
if (transA != PlasmaTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
plasma_error("PLASMA_dtrsm_Tile", "illegal value of transA");
return plasma_request_fail(sequence, request, -3);
}
if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
plasma_error("PLASMA_dtrsm_Tile", "illegal value of diag");
return plasma_request_fail(sequence, request, -4);
}
/* Quick return */
plasma_parallel_call_9(plasma_pdtrsm,
PLASMA_enum, side,
PLASMA_enum, uplo,
PLASMA_enum, transA,
PLASMA_enum, diag,
double, alpha,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

PLASMA_dtrsmpl_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_dtrsmpl_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_dtrsmpl
PLASMA_dtrsmpl_Tile
PLASMA_ctrsmpl_Tile_Async
PLASMA_dtrsmpl_Tile_Async
PLASMA_strsmpl_Tile_Async
PLASMA_dgetrf_incpiv_Tile_Async

Definition at line 240 of file dtrsmpl.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_pdtrsmpl(), 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dtrsmpl_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dtrsmpl_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dtrsmpl_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsmpl_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descL) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsmpl_Tile", "invalid second descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsmpl_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_dtrsmpl_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_parallel_call_6(plasma_pdtrsmpl,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_desc, descL,
int*, IPIV,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dtrsmrv_Tile_Async ( PLASMA_enum  side,
PLASMA_enum  uplo,
PLASMA_enum  transA,
PLASMA_enum  diag,
double  alpha,
PLASMA_desc *  A,
PLASMA_desc *  B,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dtrsmrv_Tile_Async - Computes triangular solve. Non-blocking equivalent of PLASMA_dtrsmrv_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_dtrsmrv
PLASMA_dtrsmrv_Tile
PLASMA_ctrsmrv_Tile_Async
PLASMA_dtrsmrv_Tile_Async
PLASMA_strsmrv_Tile_Async

Definition at line 298 of file dtrsmrv.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_pdtrsmrv(), plasma_request_fail(), PLASMA_SUCCESS, 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_context_t *plasma;
plasma = plasma_context_self();
if (plasma == NULL) {
plasma_fatal_error("PLASMA_dtrsmrv_Tile", "PLASMA not initialized");
return PLASMA_ERR_NOT_INITIALIZED;
}
if (sequence == NULL) {
plasma_fatal_error("PLASMA_dtrsmrv_Tile", "NULL sequence");
return PLASMA_ERR_UNALLOCATED;
}
if (request == NULL) {
plasma_fatal_error("PLASMA_dtrsmrv_Tile", "NULL request");
return PLASMA_ERR_UNALLOCATED;
}
/* Check sequence status */
if (sequence->status == PLASMA_SUCCESS)
request->status = PLASMA_SUCCESS;
else
return plasma_request_fail(sequence, request, PLASMA_ERR_SEQUENCE_FLUSHED);
/* Check descriptors for correctness */
if (plasma_desc_check(&descA) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsmrv_Tile", "invalid first descriptor");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (plasma_desc_check(&descB) != PLASMA_SUCCESS) {
plasma_error("PLASMA_dtrsmrv_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_dtrsmrv_Tile", "only square tiles supported");
return plasma_request_fail(sequence, request, PLASMA_ERR_ILLEGAL_VALUE);
}
if (side != PlasmaLeft && side != PlasmaRight) {
plasma_error("PLASMA_dtrsmrv_Tile", "illegal value of side");
return plasma_request_fail(sequence, request, -1);
}
if (uplo != PlasmaUpper && uplo != PlasmaLower) {
plasma_error("PLASMA_dtrsmrv_Tile", "illegal value of uplo");
return plasma_request_fail(sequence, request, -2);
}
if (transA != PlasmaTrans && transA != PlasmaNoTrans && transA != PlasmaTrans) {
plasma_error("PLASMA_dtrsmrv_Tile", "illegal value of transA");
return plasma_request_fail(sequence, request, -3);
}
if (diag != PlasmaUnit && diag != PlasmaNonUnit) {
plasma_error("PLASMA_dtrsmrv_Tile", "illegal value of diag");
return plasma_request_fail(sequence, request, -4);
}
if ( side != PlasmaRight ) {
plasma_error("PLASMA_dtrsmrv_Tile", "PlasmaLeft is not supported");
return plasma_request_fail(sequence, request, -1);
}
if ( uplo != PlasmaLower ) {
plasma_error("PLASMA_dtrsmrv_Tile", "PlasmaUpper is not supported");
return plasma_request_fail(sequence, request, -2);
}
if ( transA != PlasmaNoTrans ) {
plasma_error("PLASMA_dtrsmrv_Tile", "Only PlasmaNoTrans is supported");
return plasma_request_fail(sequence, request, -3);
}
if ( diag != PlasmaUnit ) {
plasma_error("PLASMA_dtrsmrv_Tile", "PlasmaNonUnit is not supported");
return plasma_request_fail(sequence, request, -4);
}
/* Quick return */
plasma_dynamic_call_9(plasma_pdtrsmrv,
PLASMA_enum, side,
PLASMA_enum, uplo,
PLASMA_enum, transA,
PLASMA_enum, diag,
double, (double) 1.0,
PLASMA_desc, descA,
PLASMA_desc, descB,
PLASMA_sequence*, sequence,
PLASMA_request*, request);
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int PLASMA_dtrtri_Tile_Async ( PLASMA_enum  uplo,
PLASMA_enum  diag,
PLASMA_desc *  A,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

PLASMA_dtrtri_Tile_Async - Computes the inverse of a complex upper or lower triangular matrix A. Non-blocking equivalent of PLASMA_dtrtri_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_dtrtri
PLASMA_dtrtri_Tile
PLASMA_ctrtri_Tile_Async
PLASMA_dtrtri_Tile_Async
PLASMA_strtri_Tile_Async
PLASMA_dpotri_Tile_Async

Definition at line 240 of file dtrtri.c.

References A, 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_request_fail(), PLASMA_SUCCESS, PlasmaLower, PlasmaNonUnit, PlasmaUnit, PlasmaUpper, plasma_request_t::status, and plasma_sequence_t::status.

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

Here is the call graph for this function:

Here is the caller graph for this function: