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

Go to the source code of this file.

Functions

int CORE_sttmlq (int side, int trans, int M1, int N1, int M2, int N2, int K, int IB, float *A1, int LDA1, float *A2, int LDA2, float *V, int LDV, float *T, int LDT, float *WORK, int LDWORK)
void QUARK_CORE_sttmlq (Quark *quark, Quark_Task_Flags *task_flags, int side, int trans, int m1, int n1, int m2, int n2, int k, int ib, int nb, float *A1, int lda1, float *A2, int lda2, float *V, int ldv, float *T, int ldt)
void CORE_sttmlq_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:18 2011

Definition in file core_sttmlq.c.

Function Documentation

int CORE_sttmlq ( int  side,
int  trans,
int  M1,
int  N1,
int  M2,
int  N2,
int  K,
int  IB,
float *  A1,
int  LDA1,
float *  A2,
int  LDA2,
float *  V,
int  LDV,
float *  T,
int  LDT,
float *  WORK,
int  LDWORK 
)

CORE_sttmlq overwrites the general complex M1-by-N1 tile A1 and M2-by-N2 tile A2 (N1 == N2) with 

                  SIDE = 'L'        SIDE = 'R'

TRANS = 'N': Q * | A1 | | A1 | * Q | A2 | | A2 |

TRANS = 'C': Q**T * | A1 | | A1 | * Q**T | A2 | | A2 |

where Q is a complex unitary matrix defined as the product of k elementary reflectors

Q = H(1) H(2) . . . H(k)

as returned by CORE_sttqrt.

Parameters:
[in]side
  • PlasmaLeft : apply Q or Q**T from the Left;
  • PlasmaRight : apply Q or Q**T from the Right.
[in]trans
  • PlasmaNoTrans : No transpose, apply Q;
  • PlasmaTrans : ConjTranspose, apply Q**T.
[in]M1The number of rows of the tile A1. M1 >= 0.
[in]N1The number of columns of the tile A1. N1 >= 0.
[in]M2The number of rows of the tile A2. M2 >= 0.
[in]N2The number of columns of the tile A2. N2 >= 0.
[in]KThe number of elementary reflectors whose product defines the matrix Q.
[in]IBThe inner-blocking size. IB >= 0.
[in,out]A1On entry, the M1-by-N1 tile A1. On exit, A1 is overwritten by the application of Q.
[in]LDA1The leading dimension of the array A1. LDA1 >= max(1,M1).
[in,out]A2On entry, the M2-by-N2 tile A2. On exit, A2 is overwritten by the application of Q.
[in]LDA2The leading dimension of the tile A2. LDA2 >= max(1,M2).
[in]VThe i-th row must contain the vector which defines the elementary reflector H(i), for i = 1,2,...,k, as returned by CORE_STTQRT in the first k rows of its array argument V.
[in]LDVThe leading dimension of the array V. LDV >= max(1,K).
[out]TThe IB-by-N1 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]WORKWorkspace array of size LDWORK-by-N1.
[in]LDWORKThe dimension of the array WORK. LDWORK >= max(1,IB).
Returns:
Return values:
PLASMA_SUCCESSsuccessful exit
<0if -i, the i-th argument had an illegal value

Definition at line 116 of file core_sttmlq.c.

References CORE_sparfb(), coreblas_error, max, min, PLASMA_SUCCESS, PlasmaForward, PlasmaLeft, PlasmaNoTrans, PlasmaRight, PlasmaRowwise, and PlasmaTrans.

{
int i, i1, i3, l;
int NQ, NW;
int kb;
int ic = 0;
int jc = 0;
int mi1 = M1;
int mi2 = M2;
int ni1 = N1;
int ni2 = N2;
/* Check input arguments */
if ((side != PlasmaLeft) && (side != PlasmaRight)) {
coreblas_error(1, "Illegal value of side");
return -1;
}
/* NQ is the order of Q */
if (side == PlasmaLeft) {
NQ = N2;
NW = IB;
}
else {
NQ = M2;
NW = N1;
}
if ((trans != PlasmaNoTrans) && (trans != PlasmaTrans)) {
coreblas_error(2, "Illegal value of trans");
return -2;
}
if (M1 < 0) {
coreblas_error(3, "Illegal value of M1");
return -3;
}
if (N1 < 0) {
coreblas_error(4, "Illegal value of N1");
return -4;
}
if ((M2 < 0) ||
( (side == PlasmaRight) && (M1 != M2) ) ) {
coreblas_error(5, "Illegal value of M2");
return -5;
}
if ((N2 < 0) ||
( (side == PlasmaLeft) && (N1 != N2) ) ) {
coreblas_error(6, "Illegal value of N2");
return -6;
}
if ((K < 0) ||
( (side == PlasmaLeft) && (K > M1) ) ||
( (side == PlasmaRight) && (K > N1) ) ) {
coreblas_error(7, "Illegal value of K");
return -7;
}
if (IB < 0) {
coreblas_error(8, "Illegal value of IB");
return -8;
}
if (LDA1 < max(1,M1)){
coreblas_error(10, "Illegal value of LDA1");
return -10;
}
if (LDA2 < max(1,M2)){
coreblas_error(12, "Illegal value of LDA2");
return -12;
}
if (LDV < max(1,NQ)){
coreblas_error(14, "Illegal value of LDV");
return -14;
}
if (LDT < max(1,IB)){
coreblas_error(16, "Illegal value of LDT");
return -16;
}
if (LDWORK < max(1,NW)){
coreblas_error(18, "Illegal value of LDWORK");
return -18;
}
/* Quick return */
if ((M1 == 0) || (N1 == 0) || (M2 == 0) || (N2 == 0) || (K == 0) || (IB == 0))
return PLASMA_SUCCESS;
if (((side == PlasmaLeft) && (trans == PlasmaNoTrans))
|| ((side == PlasmaRight) && (trans != PlasmaNoTrans))) {
i1 = 0;
i3 = IB;
}
else {
i1 = ( ( K-1 ) / IB )*IB;
i3 = -IB;
}
/* Transpose */
if (trans == PlasmaNoTrans) {
trans = PlasmaTrans;
}
else {
trans = PlasmaNoTrans;
}
for (i = i1; (i > -1) && (i < K); i+=i3) {
kb = min(IB, K-i);
if (side == PlasmaLeft) {
mi1 = kb; // M1 - i;
mi2 = min(i+kb, M2);
l = min(kb, max(0, M2-i));
ic = i;
}
else {
ni1 = kb;
ni2 = min(i+kb, N2);
l = min(kb, max(0, N2-i));
jc = i;
}
/*
* Apply H or H' (NOTE: CORE_sparfb used to be CORE_sttrfb)
*/
CORE_sparfb(
side, trans, PlasmaForward, PlasmaRowwise,
mi1, ni1, mi2, ni2, kb, l,
&A1[LDA1*jc+ic], LDA1,
A2, LDA2,
&V[i], LDV,
&T[LDT*i], LDT,
WORK, LDWORK);
}
return PLASMA_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void CORE_sttmlq_quark ( Quark *  quark)

Definition at line 299 of file core_sttmlq.c.

References CORE_sttmlq(), quark_unpack_args_18, side, T, trans, and V.

{
int side;
int trans;
int m1;
int n1;
int m2;
int n2;
int k;
int ib;
float *A1;
int lda1;
float *A2;
int lda2;
float *V;
int ldv;
float *T;
int ldt;
float *WORK;
int ldwork;
quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
CORE_sttmlq(side, trans, m1, n1, m2, n2, k, ib, A1, lda1,
A2, lda2, V, ldv, T, ldt, WORK, ldwork);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void QUARK_CORE_sttmlq ( Quark *  quark,
Quark_Task_Flags *  task_flags,
int  side,
int  trans,
int  m1,
int  n1,
int  m2,
int  n2,
int  k,
int  ib,
int  nb,
float *  A1,
int  lda1,
float *  A2,
int  lda2,
float *  V,
int  ldv,
float *  T,
int  ldt 
)

Definition at line 259 of file core_sttmlq.c.

References CORE_sttmlq_quark(), DAG_CORE_TTMLQ, INOUT, INPUT, PlasmaLeft, QUARK_Insert_Task(), QUARK_REGION_D, QUARK_REGION_L, SCRATCH, and VALUE.

{
int ldwork = side == PlasmaLeft ? ib : nb;
DAG_CORE_TTMLQ;
QUARK_Insert_Task(quark, CORE_sttmlq_quark, task_flags,
sizeof(PLASMA_enum), &side, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &m1, VALUE,
sizeof(int), &n1, VALUE,
sizeof(int), &m2, VALUE,
sizeof(int), &n2, VALUE,
sizeof(int), &k, VALUE,
sizeof(int), &ib, VALUE,
sizeof(float)*nb*nb, A1, INOUT,
sizeof(int), &lda1, VALUE,
sizeof(float)*nb*nb, A2, INOUT,
sizeof(int), &lda2, VALUE,
sizeof(float)*nb*nb, V, INPUT|QUARK_REGION_D|QUARK_REGION_L,
sizeof(int), &ldv, VALUE,
sizeof(float)*ib*nb, T, INPUT,
sizeof(int), &ldt, VALUE,
sizeof(float)*ib*nb, NULL, SCRATCH,
sizeof(int), &ldwork, VALUE,
0);
}

Here is the call graph for this function:

Here is the caller graph for this function: