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
Macros | Functions
core_sttlqt.c File Reference
#include <lapacke.h>
#include "common.h"
Include dependency graph for core_sttlqt.c:

Go to the source code of this file.

Macros

#define REAL

Functions

int CORE_sttlqt (int M, int N, int IB, float *A1, int LDA1, float *A2, int LDA2, float *T, int LDT, float *TAU, float *WORK)
void QUARK_CORE_sttlqt (Quark *quark, Quark_Task_Flags *task_flags, int m, int n, int ib, int nb, float *A1, int lda1, float *A2, int lda2, float *T, int ldt)
void CORE_sttlqt_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
Dulceneia Becker
Date:
2010-11-15 s Tue Nov 22 14:35:17 2011

Definition in file core_sttlqt.c.

Macro Definition Documentation

#define REAL

Definition at line 20 of file core_sttlqt.c.

Function Documentation

int CORE_sttlqt ( int  M,
int  N,
int  IB,
float *  A1,
int  LDA1,
float *  A2,
int  LDA2,
float *  T,
int  LDT,
float *  TAU,
float *  WORK 
)

CORE_sttlqt computes a LQ factorization of a rectangular matrix formed by coupling side-by-side a complex M-by-M lower triangular tile A1 and a complex M-by-N lower triangular tile A2:

| A1 A2 | = L * Q

The tile Q is represented as a product of elementary reflectors

Q = H(k)' . . . H(2)' H(1)', where k = min(M,N).

Each H(i) has the form

H(i) = I - tau * v * v'

where tau is a complex scalar, and v is a complex vector with v(1:i-1) = 0 and v(i) = 1; g(v(i+1:n)) is stored on exit in A2(i,1:n), and tau in TAU(i).

Parameters:
[in]MThe number of rows of the tile A1 and A2. M >= 0. The number of columns of the tile A1.
[in]NThe number of columns of the tile A2. N >= 0.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M-by-M tile A1. On exit, the elements on and below the diagonal of the array contain the M-by-M lower trapezoidal tile L; the elements above the diagonal are not referenced.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,N).
[in,out]A2On entry, the M-by-N lower triangular tile A2. On exit, the elements on and below the diagonal of the array with the array TAU, represent the unitary tile Q as a product of elementary reflectors (see Further Details).
[in]LDA2The leading dimension of the array A2. LDA2 >= max(1,M).
[out]TThe IB-by-N triangular factor T of the block reflector. T is upper triangular by block (economic storage); The rest of the array is not referenced.
[in]LDTThe leading dimension of the array T. LDT >= IB.
[out]TAUThe scalar factors of the elementary reflectors (see Further Details).
[in,out]WORK
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 100 of file core_sttlqt.c.

References cblas_saxpy(), cblas_scopy(), cblas_sgemv(), cblas_sger(), cblas_strmv(), CblasColMajor, CORE_slaset(), CORE_sparfb(), CORE_spemv(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaForward, PlasmaNonUnit, PlasmaNoTrans, PlasmaRight, PlasmaRowwise, PlasmaUpper, and PlasmaUpperLower.

{
static float zone = 1.0;
static float zzero = 0.0;
#ifdef COMPLEX
static int ione = 1;
#endif
float alpha;
int i, j, l, ii, sb, mi, ni;
/* Check input arguments */
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 ((LDA2 < max(1,M)) && (M > 0)) {
coreblas_error(7, "Illegal value of LDA2");
return -7;
}
/* Quick return */
if ((M == 0) || (N == 0) || (IB == 0))
return PLASMA_SUCCESS;
/* TODO: Need to check why some cases require
* this to not have uninitialized values */
CORE_slaset( PlasmaUpperLower, IB, N,
0., 0., T, LDT);
for(ii = 0; ii < M; ii += IB) {
sb = min(M-ii, IB);
for(i = 0; i < sb; i++) {
j = ii + i;
mi = sb-i-1;
ni = min( j + 1, N);
/*
* Generate elementary reflector H( II*IB+I ) to annihilate A( II*IB+I, II*IB+I:M ).
*/
#ifdef COMPLEX
LAPACKE_slacgv_work(ni, &A2[j], LDA2);
LAPACKE_slacgv_work(ione, &A1[LDA1*j+j], LDA1);
#endif
LAPACKE_slarfg_work(ni+1, &A1[LDA1*j+j], &A2[j], LDA2, &TAU[j]);
if (mi > 0) {
/*
* Apply H( j-1 ) to A( j:II+IB-1, j-1:M ) from the right.
*/
cblas_scopy(
mi,
&A1[LDA1*j+(j+1)], 1,
WORK, 1);
cblas_sgemv(
CblasColMajor, (CBLAS_TRANSPOSE)PlasmaNoTrans,
mi, ni,
(zone), &A2[j+1], LDA2,
&A2[j], LDA2,
(zone), WORK, 1);
alpha = -(TAU[j]);
cblas_saxpy(
mi, (alpha),
WORK, 1,
&A1[LDA1*j+j+1], 1);
cblas_sger(
CblasColMajor, mi, ni,
(alpha), WORK, 1,
&A2[j], LDA2,
&A2[j+1], LDA2);
}
/*
* Calculate T.
*/
if (i > 0 ) {
l = min(i, max(0, N-ii));
alpha = -(TAU[j]);
CORE_spemv(
PlasmaNoTrans, PlasmaRowwise,
i , min(j, N), l,
alpha, &A2[ii], LDA2,
&A2[j], LDA2,
zzero, &T[LDT*j], 1,
WORK);
/* T(0:i-1, j) = T(0:i-1, ii:j-1) * T(0:i-1, j) */
cblas_strmv(
CblasColMajor, (CBLAS_UPLO)PlasmaUpper,
(CBLAS_TRANSPOSE)PlasmaNoTrans,
(CBLAS_DIAG)PlasmaNonUnit,
i, &T[LDT*ii], LDT,
&T[LDT*j], 1);
}
#ifdef COMPLEX
LAPACKE_slacgv_work(ni, &A2[j], LDA2 );
LAPACKE_slacgv_work(ione, &A1[LDA1*j+j], LDA1 );
#endif
T[LDT*j+i] = TAU[j];
}
/* Apply Q to the rest of the matrix to the right */
if (M > ii+sb) {
mi = M-(ii+sb);
ni = min(ii+sb, N);
l = min(sb, max(0, ni-ii));
CORE_sparfb(
PlasmaRight, PlasmaNoTrans,
PlasmaForward, PlasmaRowwise,
mi, IB, mi, ni, sb, l,
&A1[LDA1*ii+ii+sb], LDA1,
&A2[ii+sb], LDA2,
&A2[ii], LDA2,
&T[LDT*ii], LDT,
WORK, M);
}
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_sttlqt_quark ( Quark *  quark)

Definition at line 273 of file core_sttlqt.c.

References CORE_sttlqt(), quark_unpack_args_11, T, and TAU.

{
int m;
int n;
int ib;
float *A1;
int lda1;
float *A2;
int lda2;
float *T;
int ldt;
float *TAU;
float *WORK;
quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
CORE_sttlqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_sttlqt ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  m,
int  n,
int  ib,
int  nb,
float *  A1,
int  lda1,
float *  A2,
int  lda2,
float *  T,
int  ldt 
)

Definition at line 244 of file core_sttlqt.c.

References CORE_sttlqt_quark(), DAG_CORE_TTLQT, INOUT, LOCALITY, OUTPUT, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
DAG_CORE_TTLQT;
QUARK_Insert_Task(quark, CORE_sttlqt_quark, task_flags,
sizeof(int), &m, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &ib, VALUE,
sizeof(float)*nb*nb, A1, INOUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &lda1, VALUE,
sizeof(float)*nb*nb, A2, INOUT|QUARK_REGION_D|QUARK_REGION_L|LOCALITY,
sizeof(int), &lda2, VALUE,
sizeof(float)*ib*nb, T, OUTPUT,
sizeof(int), &ldt, VALUE,
sizeof(float)*nb, NULL, SCRATCH,
sizeof(float)*ib*nb, NULL, SCRATCH,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function: