#include "common.h"
#include <cblas.h>
#include <math.h>

Include dependency graph for core_dtstrf.c:

Functions
int	CORE_dtstrf (int M, int N, int IB, int NB, double U, int LDU, double A, int LDA, double L, int LDL, int IPIV, double WORK, int LDWORK, int INFO)
void	QUARK_CORE_dtstrf (Quark quark, Quark_Task_Flags task_flags, int m, int n, int ib, int nb, double U, int ldu, double A, int lda, double L, int ldl, int IPIV, PLASMA_sequence sequence, PLASMA_request request, PLASMA_bool check_info, int iinfo)
void	CORE_dtstrf_quark (Quark *quark)

Detailed Description

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

Version:: 2.4.5

Author:: Hatem Ltaief; Mathieu Faverge; Jakub Kurzak

Date:: 2010-11-15 d Tue Nov 22 14:35:18 2011

Definition in file core_dtstrf.c.

Function Documentation

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

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

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

Parameters:

[in]	M	The number of rows of the tile A. M >= 0.
[in]	N	The number of columns of the tile A. N >= 0.
[in]	IB	The inner-blocking size. IB >= 0.
[in]	NB
[in,out]	U	On entry, the NB-by-N upper triangular tile. On exit, the new factor U from the factorization
[in]	LDU	The leading dimension of the array U. LDU >= max(1,NB).
[in,out]	A	On entry, the M-by-N tile to be factored. On exit, the factor L from the factorization
[in]	LDA	The leading dimension of the array A. LDA >= max(1,M).
[in,out]	L	On entry, the IB-by-N lower triangular tile. On exit, the interchanged rows form the tile A in case of pivoting.
[in]	LDL	The leading dimension of the array L. LDL >= max(1,IB).
[out]	IPIV	The pivot indices; for 1 <= i <= min(M,N), row i of the tile U was interchanged with row IPIV(i) of the tile A.
[in,out]	WORK
[in]	LDWORK	The dimension of the array WORK.
[out]	INFO

Returns:

Return values:

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

Definition at line 99 of file core_dtstrf.c.

References cblas_dcopy(), cblas_dger(), cblas_dscal(), cblas_dswap(), cblas_idamax(), CblasColMajor, CORE_dssssm(), coreblas_error, max, min, and PLASMA_SUCCESS.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_dtstrf_quark ( Quark * quark )

Definition at line 258 of file core_dtstrf.c.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 220 of file core_dtstrf.c.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Detailed Description

Function Documentation