PLASMA
Parallel Linear Algebra Software for Multicore Architectures
|
\( C = \alpha \;op(A) \;op(B) + \beta C \) More...
Functions | |
int | plasma_cgemm (plasma_enum_t transa, plasma_enum_t transb, int m, int n, int k, plasma_complex32_t alpha, plasma_complex32_t *pA, int lda, plasma_complex32_t *pB, int ldb, plasma_complex32_t beta, plasma_complex32_t *pC, int ldc) |
void | plasma_omp_cgemm (plasma_enum_t transa, plasma_enum_t transb, plasma_complex32_t alpha, plasma_desc_t A, plasma_desc_t B, plasma_complex32_t beta, plasma_desc_t C, plasma_sequence_t *sequence, plasma_request_t *request) |
int | plasma_dgemm (plasma_enum_t transa, plasma_enum_t transb, int m, int n, int k, double alpha, double *pA, int lda, double *pB, int ldb, double beta, double *pC, int ldc) |
void | plasma_omp_dgemm (plasma_enum_t transa, plasma_enum_t transb, double alpha, plasma_desc_t A, plasma_desc_t B, double beta, plasma_desc_t C, plasma_sequence_t *sequence, plasma_request_t *request) |
int | plasma_sgemm (plasma_enum_t transa, plasma_enum_t transb, int m, int n, int k, float alpha, float *pA, int lda, float *pB, int ldb, float beta, float *pC, int ldc) |
void | plasma_omp_sgemm (plasma_enum_t transa, plasma_enum_t transb, float alpha, plasma_desc_t A, plasma_desc_t B, float beta, plasma_desc_t C, plasma_sequence_t *sequence, plasma_request_t *request) |
int | plasma_zgemm (plasma_enum_t transa, plasma_enum_t transb, int m, int n, int k, plasma_complex64_t alpha, plasma_complex64_t *pA, int lda, plasma_complex64_t *pB, int ldb, plasma_complex64_t beta, plasma_complex64_t *pC, int ldc) |
void | plasma_omp_zgemm (plasma_enum_t transa, plasma_enum_t transb, plasma_complex64_t alpha, plasma_desc_t A, plasma_desc_t B, plasma_complex64_t beta, plasma_desc_t C, plasma_sequence_t *sequence, plasma_request_t *request) |
\( C = \alpha \;op(A) \;op(B) + \beta C \)
int plasma_cgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
int | m, | ||
int | n, | ||
int | k, | ||
plasma_complex32_t | alpha, | ||
plasma_complex32_t * | pA, | ||
int | lda, | ||
plasma_complex32_t * | pB, | ||
int | ldb, | ||
plasma_complex32_t | beta, | ||
plasma_complex32_t * | pC, | ||
int | ldc | ||
) |
Performs one of the matrix-matrix operations
\[ C = \alpha [op( A )\times op( B )] + \beta C, \]
where op( X ) is one of:
\[ op( X ) = X, \]
\[ op( X ) = X^T, \]
\[ op( X ) = X^H, \]
alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m-by-k matrix, op( B ) a k-by-n matrix and C an m-by-n matrix.
[in] | transa |
|
[in] | transb |
|
[in] | m | The number of rows of the matrix op( A ) and of the matrix C. m >= 0. |
[in] | n | The number of columns of the matrix op( B ) and of the matrix C. n >= 0. |
[in] | k | The number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). k >= 0. |
[in] | alpha | The scalar alpha. |
[in] | pA | An lda-by-ka matrix, where ka is k when transa = PlasmaNoTrans, and is m otherwise. |
[in] | lda | The leading dimension of the array A. When transa = PlasmaNoTrans, lda >= max(1,m), otherwise, lda >= max(1,k). |
[in] | pB | An ldb-by-kb matrix, where kb is n when transb = PlasmaNoTrans, and is k otherwise. |
[in] | ldb | The leading dimension of the array B. When transb = PlasmaNoTrans, ldb >= max(1,k), otherwise, ldb >= max(1,n). |
[in] | beta | The scalar beta. |
[in,out] | pC | An ldc-by-n matrix. On exit, the array is overwritten by the m-by-n matrix ( alpha*op( A )*op( B ) + beta*C ). |
[in] | ldc | The leading dimension of the array C. ldc >= max(1,m). |
PlasmaSuccess | successful exit |
void plasma_omp_cgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
plasma_complex32_t | alpha, | ||
plasma_desc_t | A, | ||
plasma_desc_t | B, | ||
plasma_complex32_t | beta, | ||
plasma_desc_t | C, | ||
plasma_sequence_t * | sequence, | ||
plasma_request_t * | request | ||
) |
Performs matrix multiplication. Non-blocking tile version of plasma_cgemm(). May return before the computation is finished. Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors. Allows for pipelining of operations at runtime.
[in] | transa |
|
[in] | transb |
|
[in] | alpha | The scalar alpha. |
[in] | A | Descriptor of matrix A. |
[in] | B | Descriptor of matrix B. |
[in] | beta | The scalar beta. |
[in,out] | C | Descriptor of matrix C. |
[in] | sequence | Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes). Check the sequence->status for errors. |
[out] | request | Identifies this function call (for exception handling purposes). |
void | Errors are returned by setting sequence->status and request->status to error values. The sequence->status and request->status should never be set to PlasmaSuccess (the initial values) since another async call may be setting a failure value at the same time. |
int plasma_dgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
int | m, | ||
int | n, | ||
int | k, | ||
double | alpha, | ||
double * | pA, | ||
int | lda, | ||
double * | pB, | ||
int | ldb, | ||
double | beta, | ||
double * | pC, | ||
int | ldc | ||
) |
Performs one of the matrix-matrix operations
\[ C = \alpha [op( A )\times op( B )] + \beta C, \]
where op( X ) is one of:
\[ op( X ) = X, \]
\[ op( X ) = X^T, \]
\[ op( X ) = X^T, \]
alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m-by-k matrix, op( B ) a k-by-n matrix and C an m-by-n matrix.
[in] | transa |
|
[in] | transb |
|
[in] | m | The number of rows of the matrix op( A ) and of the matrix C. m >= 0. |
[in] | n | The number of columns of the matrix op( B ) and of the matrix C. n >= 0. |
[in] | k | The number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). k >= 0. |
[in] | alpha | The scalar alpha. |
[in] | pA | An lda-by-ka matrix, where ka is k when transa = PlasmaNoTrans, and is m otherwise. |
[in] | lda | The leading dimension of the array A. When transa = PlasmaNoTrans, lda >= max(1,m), otherwise, lda >= max(1,k). |
[in] | pB | An ldb-by-kb matrix, where kb is n when transb = PlasmaNoTrans, and is k otherwise. |
[in] | ldb | The leading dimension of the array B. When transb = PlasmaNoTrans, ldb >= max(1,k), otherwise, ldb >= max(1,n). |
[in] | beta | The scalar beta. |
[in,out] | pC | An ldc-by-n matrix. On exit, the array is overwritten by the m-by-n matrix ( alpha*op( A )*op( B ) + beta*C ). |
[in] | ldc | The leading dimension of the array C. ldc >= max(1,m). |
PlasmaSuccess | successful exit |
void plasma_omp_dgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
double | alpha, | ||
plasma_desc_t | A, | ||
plasma_desc_t | B, | ||
double | beta, | ||
plasma_desc_t | C, | ||
plasma_sequence_t * | sequence, | ||
plasma_request_t * | request | ||
) |
Performs matrix multiplication. Non-blocking tile version of plasma_dgemm(). May return before the computation is finished. Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors. Allows for pipelining of operations at runtime.
[in] | transa |
|
[in] | transb |
|
[in] | alpha | The scalar alpha. |
[in] | A | Descriptor of matrix A. |
[in] | B | Descriptor of matrix B. |
[in] | beta | The scalar beta. |
[in,out] | C | Descriptor of matrix C. |
[in] | sequence | Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes). Check the sequence->status for errors. |
[out] | request | Identifies this function call (for exception handling purposes). |
void | Errors are returned by setting sequence->status and request->status to error values. The sequence->status and request->status should never be set to PlasmaSuccess (the initial values) since another async call may be setting a failure value at the same time. |
int plasma_sgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
int | m, | ||
int | n, | ||
int | k, | ||
float | alpha, | ||
float * | pA, | ||
int | lda, | ||
float * | pB, | ||
int | ldb, | ||
float | beta, | ||
float * | pC, | ||
int | ldc | ||
) |
Performs one of the matrix-matrix operations
\[ C = \alpha [op( A )\times op( B )] + \beta C, \]
where op( X ) is one of:
\[ op( X ) = X, \]
\[ op( X ) = X^T, \]
\[ op( X ) = X^T, \]
alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m-by-k matrix, op( B ) a k-by-n matrix and C an m-by-n matrix.
[in] | transa |
|
[in] | transb |
|
[in] | m | The number of rows of the matrix op( A ) and of the matrix C. m >= 0. |
[in] | n | The number of columns of the matrix op( B ) and of the matrix C. n >= 0. |
[in] | k | The number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). k >= 0. |
[in] | alpha | The scalar alpha. |
[in] | pA | An lda-by-ka matrix, where ka is k when transa = PlasmaNoTrans, and is m otherwise. |
[in] | lda | The leading dimension of the array A. When transa = PlasmaNoTrans, lda >= max(1,m), otherwise, lda >= max(1,k). |
[in] | pB | An ldb-by-kb matrix, where kb is n when transb = PlasmaNoTrans, and is k otherwise. |
[in] | ldb | The leading dimension of the array B. When transb = PlasmaNoTrans, ldb >= max(1,k), otherwise, ldb >= max(1,n). |
[in] | beta | The scalar beta. |
[in,out] | pC | An ldc-by-n matrix. On exit, the array is overwritten by the m-by-n matrix ( alpha*op( A )*op( B ) + beta*C ). |
[in] | ldc | The leading dimension of the array C. ldc >= max(1,m). |
PlasmaSuccess | successful exit |
void plasma_omp_sgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
float | alpha, | ||
plasma_desc_t | A, | ||
plasma_desc_t | B, | ||
float | beta, | ||
plasma_desc_t | C, | ||
plasma_sequence_t * | sequence, | ||
plasma_request_t * | request | ||
) |
Performs matrix multiplication. Non-blocking tile version of plasma_sgemm(). May return before the computation is finished. Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors. Allows for pipelining of operations at runtime.
[in] | transa |
|
[in] | transb |
|
[in] | alpha | The scalar alpha. |
[in] | A | Descriptor of matrix A. |
[in] | B | Descriptor of matrix B. |
[in] | beta | The scalar beta. |
[in,out] | C | Descriptor of matrix C. |
[in] | sequence | Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes). Check the sequence->status for errors. |
[out] | request | Identifies this function call (for exception handling purposes). |
void | Errors are returned by setting sequence->status and request->status to error values. The sequence->status and request->status should never be set to PlasmaSuccess (the initial values) since another async call may be setting a failure value at the same time. |
int plasma_zgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
int | m, | ||
int | n, | ||
int | k, | ||
plasma_complex64_t | alpha, | ||
plasma_complex64_t * | pA, | ||
int | lda, | ||
plasma_complex64_t * | pB, | ||
int | ldb, | ||
plasma_complex64_t | beta, | ||
plasma_complex64_t * | pC, | ||
int | ldc | ||
) |
Performs one of the matrix-matrix operations
\[ C = \alpha [op( A )\times op( B )] + \beta C, \]
where op( X ) is one of:
\[ op( X ) = X, \]
\[ op( X ) = X^T, \]
\[ op( X ) = X^H, \]
alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m-by-k matrix, op( B ) a k-by-n matrix and C an m-by-n matrix.
[in] | transa |
|
[in] | transb |
|
[in] | m | The number of rows of the matrix op( A ) and of the matrix C. m >= 0. |
[in] | n | The number of columns of the matrix op( B ) and of the matrix C. n >= 0. |
[in] | k | The number of columns of the matrix op( A ) and the number of rows of the matrix op( B ). k >= 0. |
[in] | alpha | The scalar alpha. |
[in] | pA | An lda-by-ka matrix, where ka is k when transa = PlasmaNoTrans, and is m otherwise. |
[in] | lda | The leading dimension of the array A. When transa = PlasmaNoTrans, lda >= max(1,m), otherwise, lda >= max(1,k). |
[in] | pB | An ldb-by-kb matrix, where kb is n when transb = PlasmaNoTrans, and is k otherwise. |
[in] | ldb | The leading dimension of the array B. When transb = PlasmaNoTrans, ldb >= max(1,k), otherwise, ldb >= max(1,n). |
[in] | beta | The scalar beta. |
[in,out] | pC | An ldc-by-n matrix. On exit, the array is overwritten by the m-by-n matrix ( alpha*op( A )*op( B ) + beta*C ). |
[in] | ldc | The leading dimension of the array C. ldc >= max(1,m). |
PlasmaSuccess | successful exit |
void plasma_omp_zgemm | ( | plasma_enum_t | transa, |
plasma_enum_t | transb, | ||
plasma_complex64_t | alpha, | ||
plasma_desc_t | A, | ||
plasma_desc_t | B, | ||
plasma_complex64_t | beta, | ||
plasma_desc_t | C, | ||
plasma_sequence_t * | sequence, | ||
plasma_request_t * | request | ||
) |
Performs matrix multiplication. Non-blocking tile version of plasma_zgemm(). May return before the computation is finished. Operates on matrices stored by tiles. All matrices are passed through descriptors. All dimensions are taken from the descriptors. Allows for pipelining of operations at runtime.
[in] | transa |
|
[in] | transb |
|
[in] | alpha | The scalar alpha. |
[in] | A | Descriptor of matrix A. |
[in] | B | Descriptor of matrix B. |
[in] | beta | The scalar beta. |
[in,out] | C | Descriptor of matrix C. |
[in] | sequence | Identifies the sequence of function calls that this call belongs to (for completion checks and exception handling purposes). Check the sequence->status for errors. |
[out] | request | Identifies this function call (for exception handling purposes). |
void | Errors are returned by setting sequence->status and request->status to error values. The sequence->status and request->status should never be set to PlasmaSuccess (the initial values) since another async call may be setting a failure value at the same time. |