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

Go to the source code of this file.

Macros

#define A(m, n, i, j, ldt)   (BLKADDR(A, double, m, n)+((j)*(ldt)+(i)))

Functions

void plasma_pdlansy (plasma_context_t *plasma)
void plasma_pdlansy_quark (PLASMA_enum norm, PLASMA_enum uplo, PLASMA_desc A, double *work, double *result, PLASMA_sequence *sequence, PLASMA_request *request)

Detailed Description

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

Version:
2.4.5
Author:
Emmanuel Agullo
Mathieu Faverge
Date:
2010-11-15 d Tue Nov 22 14:35:40 2011

Definition in file pdlansy.c.

Macro Definition Documentation

#define A (   m,
  n,
  i,
  j,
  ldt 
)    (BLKADDR(A, double, m, n)+((j)*(ldt)+(i)))

Definition at line 20 of file pdlansy.c.

Function Documentation

void plasma_pdlansy ( plasma_context_t *  plasma)

Definition at line 24 of file pdlansy.c.

References A, BLKLDD, CORE_dasum(), CORE_dlange(), CORE_dlansy(), plasma_desc_t::i, plasma_desc_t::j, plasma_desc_t::m, max, plasma_desc_t::mb, plasma_desc_t::mt, plasma_desc_t::n, plasma_desc_t::nb, norm, plasma_desc_t::nt, plasma_private_alloc(), plasma_private_free(), PLASMA_RANK, PLASMA_SIZE, plasma_unpack_args_7, PlasmaColumnwise, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaLower, PlasmaMaxNorm, PlasmaOneNorm, PlasmaRealDouble, PlasmaRowwise, PlasmaUpperLower, ss_cond_set, ss_cond_wait, ss_finalize, ss_init, and uplo.

{
PLASMA_enum norm;
PLASMA_enum uplo;
PLASMA_desc A;
double *work;
double *result;
PLASMA_sequence *sequence;
PLASMA_request *request;
int m, n;
int next_m;
int next_n;
int ldam, ldan;
int step, lrank;
int X, X1, X2, Y, Y1, Y2;
double* lwork;
double normtmp, normtmp2;
plasma_unpack_args_7(norm, uplo, A, work, result, sequence, request);
*result = 0.0;
if (PLASMA_RANK == 0)
memset(work, 0, PLASMA_SIZE*sizeof(double));
ss_init(PLASMA_SIZE, 1, 0);
switch (norm) {
/*
* PlasmaMaxNorm
*/
case PlasmaMaxNorm:
n = 0;
m = PLASMA_RANK;
while (m >= A.mt && n < A.nt) {
n++;
m = m-A.mt+n;
}
while (n < A.nt) {
next_m = m;
next_n = n;
next_m += PLASMA_SIZE;
while (next_m >= A.mt && next_n < A.nt) {
next_n++;
next_m = next_m-A.mt+next_n;
}
if (m == n) {
X1 = m == 0 ? A.i %A.mb : 0;
X2 = m == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
ldam = BLKLDD(A, m);
CORE_dlansy(PlasmaMaxNorm, uplo, X, A(m, n, X1, X1, ldam), ldam, NULL, &normtmp);
}
else {
/*
* PlasmaLower
*/
if (uplo == PlasmaLower) {
X1 = m == 0 ? A.i %A.mb : 0;
X2 = m == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
Y1 = n == 0 ? A.j %A.nb : 0;
Y2 = n == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
Y = Y2 - Y1;
ldam = BLKLDD(A, m);
CORE_dlange(PlasmaMaxNorm, X, Y, A(m, n, X1, Y1, ldam), ldam, NULL, &normtmp);
}
/*
* PlasmaUpper
*/
else {
X1 = n == 0 ? A.i %A.mb : 0;
X2 = n == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
Y1 = m == 0 ? A.j %A.nb : 0;
Y2 = m == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
Y = Y2 - Y1;
ldan = BLKLDD(A, n);
CORE_dlange(PlasmaMaxNorm, X, Y, A(n, m, X1, Y1, ldan), ldan, NULL, &normtmp);
}
}
if (normtmp > work[PLASMA_RANK])
work[PLASMA_RANK] = normtmp;
m = next_m;
n = next_n;
}
ss_cond_set(PLASMA_RANK, 0, 1);
break;
/*
* PlasmaOneNorm / PlasmaInfNorm
*/
case PlasmaOneNorm:
case PlasmaInfNorm:
m = PLASMA_RANK;
normtmp2 = 0.0;
lwork = (double*)plasma_private_alloc(plasma, A.mb, PlasmaRealDouble);
while (m < A.mt) {
X1 = m == 0 ? A.i %A.mb : 0;
X2 = m == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
ldam = BLKLDD(A, m);
memset(lwork, 0, A.mb*sizeof(double));
/*
* PlasmaLower
*/
if (uplo == PlasmaLower) {
for (n = 0; n < m; n++) {
Y1 = n == 0 ? A.j%A.nb : 0;
Y = A.nb - Y1;
CORE_dasum(PlasmaRowwise, PlasmaUpperLower, X, Y, A(m, n, X1, Y1, ldam), ldam, lwork);
}
CORE_dasum(PlasmaRowwise, uplo, X, X, A(m, m, X1, X1, ldam), ldam, lwork);
for (n = m+1; n < A.mt; n++) {
Y = n == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
ldan = BLKLDD(A, n);
CORE_dasum(PlasmaColumnwise, PlasmaUpperLower, Y, X, A(n, m, 0, X1, ldan), ldan, lwork);
}
}
/*
* PlasmaUpper
*/
else {
for (n = 0; n < m; n++) {
Y1 = n == 0 ? A.j%A.nb : 0;
Y = A.nb - Y1;
CORE_dasum(PlasmaColumnwise, PlasmaUpperLower, Y, X, A(n, m, Y1, X1, A.nb), A.nb, lwork);
}
CORE_dasum(PlasmaRowwise, uplo, X, X, A(m, m, X1, X1, ldam), ldam, lwork);
for ( n =m+1; n < A.mt; n++) {
Y = n == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
CORE_dasum(PlasmaRowwise, PlasmaUpperLower, X, Y, A(m, n, X1, 0, ldam), ldam, lwork);
}
}
CORE_dlange(PlasmaMaxNorm, X, 1, lwork, 1, NULL, &normtmp);
if (normtmp > normtmp2)
normtmp2 = normtmp;
m += PLASMA_SIZE;
}
work[PLASMA_RANK] = normtmp2;
ss_cond_set(PLASMA_RANK, 0, 1);
plasma_private_free(plasma, lwork);
break;
/*
* PlasmaFrobeniusNorm
*/
case PlasmaFrobeniusNorm:
default:;
}
if (norm != PlasmaFrobeniusNorm) {
step = 1;
lrank = PLASMA_RANK;
while ( (lrank%2 == 0) && (PLASMA_RANK+step < PLASMA_SIZE) ) {
ss_cond_wait(PLASMA_RANK+step, 0, step);
work[PLASMA_RANK] = max(work[PLASMA_RANK], work[PLASMA_RANK+step]);
lrank = lrank >> 1;
step = step << 1;
ss_cond_set(PLASMA_RANK, 0, step);
}
if (PLASMA_RANK > 0) {
while( lrank != 0 ) {
if (lrank%2 == 1) {
ss_cond_set(PLASMA_RANK, 0, step);
lrank = 0;
} else {
lrank = lrank >> 1;
step = step << 1;
ss_cond_set(PLASMA_RANK, 0, step);
}
}
}
if (PLASMA_RANK == 0)
*result = work[0];
}
ss_finalize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plasma_pdlansy_quark ( PLASMA_enum  norm,
PLASMA_enum  uplo,
PLASMA_desc  A,
double *  work,
double *  result,
PLASMA_sequence *  sequence,
PLASMA_request *  request 
)

Definition at line 219 of file pdlansy.c.

References BLKLDD, plasma_desc_t::i, plasma_desc_t::j, plasma_desc_t::m, plasma_desc_t::mb, plasma_desc_t::mt, plasma_desc_t::n, plasma_desc_t::nb, plasma_desc_t::nt, plasma_context_self(), plasma_shared_alloc(), PLASMA_SUCCESS, PlasmaColumnwise, PlasmaFrobeniusNorm, PlasmaInfNorm, PlasmaLower, PlasmaMaxNorm, PlasmaOneNorm, PlasmaRealDouble, PlasmaRowwise, PlasmaUpperLower, plasma_context_struct::quark, QUARK_CORE_dasum_f1(), QUARK_CORE_dlange(), QUARK_CORE_dlange_f1(), QUARK_CORE_dlansy_f1(), QUARK_CORE_free(), plasma_sequence_t::quark_sequence, QUARK_Task_Flag_Set(), Quark_Task_Flags_Initializer, plasma_sequence_t::status, and TASK_SEQUENCE.

{
plasma_context_t *plasma;
Quark_Task_Flags task_flags = Quark_Task_Flags_Initializer;
int X, X1, X2, Y, Y1;
int ldam;
int m, n;
int szeW, pos;
double* lwork;
plasma = plasma_context_self();
if (sequence->status != PLASMA_SUCCESS)
return;
QUARK_Task_Flag_Set(&task_flags, TASK_SEQUENCE, (intptr_t)sequence->quark_sequence);
*result = 0.0;
switch ( norm ) {
/*
* PlasmaMaxNorm
*/
case PlasmaMaxNorm:
szeW = A.mt*(A.mt+1)/2;
pos = 0;
lwork = (double*)plasma_shared_alloc(plasma, szeW, PlasmaRealDouble);
memset(lwork, 0, szeW*sizeof(double));
for(m = 0; m < A.mt; m++) {
X1 = m == 0 ? A.i %A.mb : 0;
X2 = m == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
ldam = BLKLDD(A, m);
QUARK_CORE_dlansy_f1(
plasma->quark, &task_flags,
PlasmaMaxNorm, uplo, X,
A(m, m, X1, X1, ldam), ldam, ldam*X,
0, &(lwork[pos]),
lwork, szeW);
pos++;
/*
* PlasmaLower
*/
if (uplo == PlasmaLower) {
for(n=0; n<m; n++) {
Y1 = n == 0 ? A.j%A.nb : 0;
Y = A.nb - Y1;
QUARK_CORE_dlange_f1(
plasma->quark, &task_flags,
PlasmaMaxNorm, X, Y,
A(m, n, X1, Y1, ldam), ldam, ldam*Y,
0, &(lwork[pos]),
lwork, szeW);
pos++;
}
}
/*
* PlasmaUpper
*/
else {
for(n = m+1; n < A.mt; n++) {
Y = n == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
QUARK_CORE_dlange_f1(
plasma->quark, &task_flags,
PlasmaMaxNorm, X, Y,
A(m, n, X1, 0, ldam), ldam, ldam*Y,
0, &(lwork[pos]),
lwork, szeW);
pos++;
}
}
}
QUARK_CORE_dlange(
plasma->quark, &task_flags,
PlasmaMaxNorm, szeW, 1,
lwork, 1, szeW,
0, result);
QUARK_CORE_free(plasma->quark, &task_flags, lwork, szeW*sizeof(double));
break;
/*
* PlasmaOneNorm / PlasmaInfNorm
*/
case PlasmaOneNorm:
case PlasmaInfNorm:
lwork = (double *)plasma_shared_alloc(plasma, A.m+1, PlasmaRealDouble);
memset(lwork, 0, (A.m+1)*sizeof(double));
for(m = 0; m < A.mt; m++) {
X1 = m == 0 ? A.i %A.mb : 0;
X2 = m == A.mt-1 ? (A.i+A.m-1)%A.mb+1 : A.mb;
X = X2 - X1;
ldam = BLKLDD(A, m);
QUARK_CORE_dasum_f1(
plasma->quark, &task_flags,
PlasmaRowwise, uplo, X, X,
A(m, m, X1, X1, ldam), ldam, ldam*X,
&(lwork[m*A.mb+1]), A.mb,
lwork, A.m);
/*
* PlasmaLower
*/
if (uplo == PlasmaLower) {
for(n = 0; n < m; n++) {
Y1 = n == 0 ? A.j%A.nb : 0;
Y = A.nb - Y1;
QUARK_CORE_dasum_f1(
plasma->quark, &task_flags,
PlasmaRowwise, PlasmaUpperLower, X, Y,
A(m, n, X1, Y1, ldam), ldam, ldam*Y,
&(lwork[m*A.mb+1]), A.mb,
lwork, A.m);
QUARK_CORE_dasum_f1(
plasma->quark, &task_flags,
PlasmaColumnwise, PlasmaUpperLower, X, Y,
A(m, n, X1, Y1, ldam), ldam, ldam*Y,
&(lwork[n*A.mb+1]), A.mb,
lwork, A.m);
}
}
/*
* PlasmaUpper
*/
else {
for(n = m+1; n < A.mt; n++) {
Y = n == A.nt-1 ? (A.j+A.n-1)%A.nb+1 : A.nb;
QUARK_CORE_dasum_f1(
plasma->quark, &task_flags,
PlasmaRowwise, PlasmaUpperLower, X, Y,
A(m, n, X1, 0, ldam), ldam, ldam*Y,
&(lwork[m*A.mb+1]), A.mb,
lwork, A.m);
QUARK_CORE_dasum_f1(
plasma->quark, &task_flags,
PlasmaColumnwise, PlasmaUpperLower, X, Y,
A(m, n, X1, 0, ldam), ldam, ldam*Y,
&(lwork[n*A.mb+1]), A.mb,
lwork, A.m);
}
}
}
QUARK_CORE_dlange(
plasma->quark, &task_flags,
PlasmaMaxNorm, A.m+1, 1,
lwork, 1, A.m+1,
0, result);
QUARK_CORE_free(plasma->quark, &task_flags, lwork, (A.m+1)*sizeof(double));
break;
/*
* PlasmaFrobeniusNorm - not implemented
*/
case PlasmaFrobeniusNorm:
default:;
}
}

Here is the call graph for this function: