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

Include dependency graph for core_ststrf.c:

Functions
int	CORE_ststrf (int M, int N, int IB, int NB, float U, int LDU, float A, int LDA, float L, int LDL, int IPIV, float WORK, int LDWORK, int INFO)
void	QUARK_CORE_ststrf (Quark quark, Quark_Task_Flags task_flags, int m, int n, int ib, int nb, float U, int ldu, float A, int lda, float L, int ldl, int IPIV, PLASMA_sequence sequence, PLASMA_request request, PLASMA_bool check_info, int iinfo)
void	CORE_ststrf_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 s Tue Nov 22 14:35:18 2011

Definition in file core_ststrf.c.

Function Documentation

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

CORE_ststrf 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_ststrf.c.

References cblas_isamax(), cblas_scopy(), cblas_sger(), cblas_sscal(), cblas_sswap(), CblasColMajor, CORE_sssssm(), coreblas_error, max, min, and PLASMA_SUCCESS.

{
    static float zzero = 0.0;
    static float mzone =-1.0;
    float 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(float));
    ip = 0;
    for (ii = 0; ii < N; ii += IB) {
        sb = min(N-ii, IB);
        for (i = 0; i < sb; i++) {
            im = cblas_isamax(M, &A[LDA*(ii+i)], 1);
            IPIV[ip] = ii+i+1;
            if (fabsf(A[LDA*(ii+i)+im]) > fabsf(U[LDU*(ii+i)+ii+i])) {
                /*
                 * Swap behind.
                 */
                cblas_sswap(i, &L[LDL*ii+i], LDL, &WORK[im], LDWORK );
                /*
                 * Swap ahead.
                 */
                cblas_sswap(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) && (fabsf(A[LDA*(ii+i)+im]) == zzero)
                && (fabsf(U[LDU*(ii+i)+ii+i]) == zzero)) {
                *INFO = ii+i+1;
            }
            alpha = ((float)1. / U[LDU*(ii+i)+ii+i]);
            cblas_sscal(M, (alpha), &A[LDA*(ii+i)], 1);
            cblas_scopy(M, &A[LDA*(ii+i)], 1, &WORK[LDWORK*i], 1);
            cblas_sger(
                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_sssssm(
                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_ststrf_quark ( Quark * quark )

Definition at line 258 of file core_ststrf.c.

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

{
    int m;
    int n;
    int ib;
    int nb;
    float *U;
    int ldu;
    float *A;
    int lda;
    float *L;
    int ldl;
    int *IPIV;
    float *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_ststrf(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_ststrf	(	Quark *	quark,
		Quark_Task_Flags *	task_flags,
		int	m,
		int	n,
		int	ib,
		int	nb,
		float *	U,
		int	ldu,
		float *	A,
		int	lda,
		float *	L,
		int	ldl,
		int *	IPIV,
		PLASMA_sequence *	sequence,
		PLASMA_request *	request,
		PLASMA_bool	check_info,
		int	iinfo
	)

Definition at line 220 of file core_ststrf.c.

References CORE_ststrf_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_ststrf_quark, task_flags,
        sizeof(int),                        &m,             VALUE,
        sizeof(int),                        &n,             VALUE,
        sizeof(int),                        &ib,            VALUE,
        sizeof(int),                        &nb,            VALUE,
        sizeof(float)*nb*nb,    U,                     INOUT | QUARK_REGION_D | QUARK_REGION_U,
        sizeof(int),                        &ldu,           VALUE,
        sizeof(float)*nb*nb,    A,                     INOUT | LOCALITY,
        sizeof(int),                        &lda,           VALUE,
        sizeof(float)*ib*nb,    L,                     OUTPUT,
        sizeof(int),                        &ldl,           VALUE,
        sizeof(int)*nb,                      IPIV,                  OUTPUT,
        sizeof(float)*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