int testing_cgetmi(int argc, char **argv){
PLASMA_Complex32_t *A, *B;
int m, n, mb, nb;
int i, ret, size;
/* Check for number of arguments*/
if (argc != 4){
USAGE("GETMI", "M N MB NB ntdbypb with \n",
" - M : the number of rows of the matrix \n"
" - N : the number of columns of the matrix \n"
" - MB : the number of rows of each block \n"
" - NB : the number of columns of each block \n");
return -1;
}
m = atoi(argv[0]);
n = atoi(argv[1]);
mb = atoi(argv[2]);
nb = atoi(argv[3]);
size = m*n*sizeof(PLASMA_Complex32_t);
A = (PLASMA_Complex32_t *)malloc(size);
B = (PLASMA_Complex32_t *)malloc(size);
LAPACKE_clarnv_work(1, ISEED, m*n, A);
for(i=0; i<6; i++) {
memcpy(B, A, size);
printf(" - TESTING CGETMI (%4s) ...", formatstr[i]);
ret = PLASMA_cgetmi( m, n, A, format[i], mb, nb );
if (ret != PLASMA_SUCCESS) {
printf("Failed\n");
continue;
}
if ( check_solution(m, n, mb, nb, B, A,
(int (*)(int, int, int, int, int, int))formatmap[i]) == 0 )
printf("............ PASSED !\n");
else
printf("... FAILED !\n");
}
free( A ); free( B );
return 0;
}
int main ()
{
int cores = 2;
int N = 10 ;
int LDA = 10 ;
int NRHS = 5 ;
int LDB = 10 ;
int info;
int info_solution;
int i,j;
int NminusOne = N-1;
int LDBxNRHS = LDB*NRHS;
PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B1 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B2 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDA*sizeof(PLASMA_Complex32_t));
float *D = (float *)malloc(LDA*sizeof(float));
/* Check if unable to allocate memory */
if ((!A1)||(!A2)||(!B1)||(!B2)) {
printf("Out of Memory \n ");
exit(0);
}
/* Plasma Initialize */
PLASMA_Init(cores);
printf("-- PLASMA is initialized to run on %d cores. \n",cores);
/* Initialize A1 and A2 for Symmetric Positive Matrix */
LAPACKE_slarnv_work(IONE, ISEED, LDA, D);
claghe(&N, &NminusOne, D, A1, &LDA, ISEED, WORK, &info);
for ( i = 0; i < N; i++)
for ( j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i];
for ( i = 0; i < N; i++) {
A1[LDA*i+i] = A1[LDA*i+i]+ (PLASMA_Complex32_t)N ;
A2[LDA*i+i] = A1[LDA*i+i];
}
/* Initialize B1 and B2 */
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for ( i = 0; i < N; i++)
for ( j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i];
/* PLASMA routines */
info = PLASMA_cpotrf(PlasmaLower, N, A2, LDA);
info = PLASMA_ctrsm(PlasmaLeft, PlasmaLower, PlasmaNoTrans, PlasmaNonUnit,
N, NRHS, (PLASMA_Complex32_t)1.0, A2, LDA, B2, LDB);
info = PLASMA_ctrsm(PlasmaLeft, PlasmaLower, PlasmaConjTrans, PlasmaNonUnit,
N, NRHS, (PLASMA_Complex32_t)1.0, A2, LDA, B2, LDB);
/* Check the solution */
info_solution = check_solution(N, NRHS, A1, LDA, B1, B2, LDB);
if ((info_solution != 0)|(info != 0))
printf("-- Error in CTRSM example ! \n");
else
printf("-- Run of CTRSM example successful ! \n");
free(A1);
free(A2);
free(B1);
free(B2);
free(WORK);
free(D);
PLASMA_Finalize();
exit(0);
}
static int
RunTest(int *iparam, _PREC *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *A, *Acpy = NULL;
real_Double_t t;
int n = iparam[TIMING_N];
int nb = iparam[TIMING_NB];
int check = iparam[TIMING_CHECK];
n = ((n % nb) == 0) ? (n / nb) * nb : ((n / nb) + 1) * nb ;
dparam[TIMING_ANORM] = (_PREC)n;
dparam[TIMING_BNORM] = (_PREC)_FADDS;
/* Allocate Data */
A = (PLASMA_Complex32_t *)malloc(n*n*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( (!A) ) {
printf("Out of Memory \n ");
exit(0);
}
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
/* } */
/* Initialiaze Data */
LAPACKE_clarnv_work(1, ISEED, n*n, A);
/* Save A and b */
if (check) {
Acpy = (PLASMA_Complex32_t *)malloc(n*n*sizeof(PLASMA_Complex32_t));
LAPACKE_clacpy_work(LAPACK_COL_MAJOR, lapack_const(PlasmaUpperLower), n, n, A, n, Acpy, n);
}
t = -cWtime();
PLASMA_cgecfi( n, n, A, PlasmaCM, n, 1, PlasmaCCRB, nb, nb);
t += cWtime();
*t_ = t;
/* Check the solution */
if (check)
{
dparam[TIMING_RES] = (_PREC)c_check_conversion(n, n, n, 1, nb, nb, Acpy, A, map_CM, map_CCRB);
free(Acpy);
}
free( A );
PLASMA_Finalize();
return 0;
}
static int
RunTest(int *iparam, float *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *A = NULL, *AT, *b, *bT, *x;
PLASMA_desc *descA, *descB, *descL;
real_Double_t t;
int *piv;
int nb, nb2, nt;
int n = iparam[TIMING_N];
int nrhs = iparam[TIMING_NRHS];
int check = iparam[TIMING_CHECK];
int lda = n;
int ldb = n;
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
PLASMA_Set(PLASMA_INNER_BLOCK_SIZE, iparam[TIMING_IB] );
/* } else { */
/* PLASMA_Get(PLASMA_TILE_SIZE, &iparam[TIMING_NB] ); */
/* PLASMA_Get(PLASMA_INNER_BLOCK_SIZE, &iparam[TIMING_IB] ); */
/* } */
nb = iparam[TIMING_NB];
nb2 = nb * nb;
nt = n / nb + ((n % nb == 0) ? 0 : 1);
/* Allocate Data */
AT = (PLASMA_Complex32_t *)malloc(nt*nt*nb2*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( !AT ) {
printf("Out of Memory \n ");
exit(0);
}
/* Initialiaze Data */
PLASMA_Desc_Create(&descA, AT, PlasmaComplexFloat, nb, nb, nb*nb, n, n, 0, 0, n, n);
LAPACKE_clarnv_work(1, ISEED, nt*nt*nb2, AT);
/* Allocate Workspace */
PLASMA_Alloc_Workspace_cgesv_incpiv_Tile(n, &descL, &piv);
/* Save AT in lapack layout for check */
if ( check ) {
A = (PLASMA_Complex32_t *)malloc(lda*n *sizeof(PLASMA_Complex32_t));
PLASMA_Tile_to_Lapack(descA, (void*)A, n);
}
t = -cWtime();
PLASMA_cgetrf_incpiv_Tile( descA, descL, piv );
t += cWtime();
*t_ = t;
/* Check the solution */
if ( check )
{
b = (PLASMA_Complex32_t *)malloc(ldb*nrhs *sizeof(PLASMA_Complex32_t));
bT = (PLASMA_Complex32_t *)malloc(nt*nb2 *sizeof(PLASMA_Complex32_t));
x = (PLASMA_Complex32_t *)malloc(ldb*nrhs *sizeof(PLASMA_Complex32_t));
LAPACKE_clarnv_work(1, ISEED, n*nrhs, b);
PLASMA_Desc_Create(&descB, bT, PlasmaComplexFloat, nb, nb, nb*nb, n, nrhs, 0, 0, n, nrhs);
PLASMA_Lapack_to_Tile((void*)b, n, descB);
PLASMA_cgetrs_incpiv_Tile( descA, descL, piv, descB );
PLASMA_Tile_to_Lapack(descB, (void*)x, n);
dparam[TIMING_RES] = c_check_solution(n, n, nrhs, A, lda, b, x, ldb,
&(dparam[TIMING_ANORM]), &(dparam[TIMING_BNORM]),
&(dparam[TIMING_XNORM]));
PLASMA_Desc_Destroy(&descB);
free( A );
free( b );
free( bT );
free( x );
}
/* Deallocate Workspace */
PLASMA_Dealloc_Handle_Tile(&descL);
PLASMA_Desc_Destroy(&descA);
free( AT );
free( piv );
PLASMA_Finalize();
return 0;
}
int testing_cher2k(int argc, char **argv)
{
/* Check for number of arguments*/
if ( argc != 7 ){
USAGE("HER2K", "alpha beta M N LDA LDB LDC",
" - alpha : alpha coefficient\n"
" - beta : beta coefficient\n"
" - N : number of columns and rows of matrix C and number of row of matrix A and B\n"
" - K : number of columns of matrix A and B\n"
" - LDA : leading dimension of matrix A\n"
" - LDB : leading dimension of matrix B\n"
" - LDC : leading dimension of matrix C\n");
return -1;
}
PLASMA_Complex32_t alpha = (PLASMA_Complex32_t) atol(argv[0]);
float beta = (float) atol(argv[1]);
int N = atoi(argv[2]);
int K = atoi(argv[3]);
int LDA = atoi(argv[4]);
int LDB = atoi(argv[5]);
int LDC = atoi(argv[6]);
int NKmax = max(N, K);
int NminusOne = N - 1;
float eps;
int info_solution;
int info, u, t;
size_t LDAxK = LDA*NKmax;
size_t LDBxK = LDB*NKmax;
size_t LDCxN = LDC*N;
PLASMA_Complex32_t *A = (PLASMA_Complex32_t *)malloc(LDAxK*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B = (PLASMA_Complex32_t *)malloc(LDBxK*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *C = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *Cinit = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *Cfinal = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDC*sizeof(PLASMA_Complex32_t));
float *D = (float *) malloc(LDC *sizeof(float));
/* Check if unable to allocate memory */
if ( (!A) || (!B) || (!Cinit) || (!Cfinal) || (!D) ){
printf("Out of Memory \n ");
return -2;
}
eps = LAPACKE_slamch_work('e');
printf("\n");
printf("------ TESTS FOR PLASMA CHER2K ROUTINE ------- \n");
printf(" Size of the Matrix C %d by %d\n", N, K);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 10.\n");
/*----------------------------------------------------------
* TESTING CHER2K
*/
/* Initialize A,B */
LAPACKE_clarnv_work(IONE, ISEED, LDAxK, A);
LAPACKE_clarnv_work(IONE, ISEED, LDBxK, B);
/* Initialize C */
LAPACKE_slarnv_work(IONE, ISEED, LDC, D);
claghe(&N, &NminusOne, D, C, &LDC, ISEED, WORK, &info);
free(D); free(WORK);
for (u=0; u<2; u++) {
for (t=0; t<3; t++) {
if (trans[t] == PlasmaTrans) continue;
memcpy(Cinit, C, LDCxN*sizeof(PLASMA_Complex32_t));
memcpy(Cfinal, C, LDCxN*sizeof(PLASMA_Complex32_t));
/* PLASMA CHER2K */
PLASMA_cher2k(uplo[u], trans[t], N, K, alpha, A, LDA, B, LDB, beta, Cfinal, LDC);
/* Check the solution */
info_solution = check_solution(uplo[u], trans[t], N, K,
alpha, A, LDA, B, LDB, beta, Cinit, Cfinal, LDC);
if (info_solution == 0) {
printf("***************************************************\n");
printf(" ---- TESTING CHER2K (%5s, %s) ........... PASSED !\n", uplostr[u], transstr[t]);
printf("***************************************************\n");
}
else {
printf("************************************************\n");
printf(" - TESTING CHER2K (%5s, %s) ... FAILED !\n", uplostr[u], transstr[t]);
printf("************************************************\n");
}
}
}
free(A); free(B); free(C);
free(Cinit); free(Cfinal);
return 0;
}
static int
RunTest(int *iparam, float *dparam, real_Double_t *t_)
{
plasma_context_t *plasma;
Quark_Task_Flags task_flags = Quark_Task_Flags_Initializer;
PLASMA_Complex32_t *A, *AT, *A2 = NULL;
PLASMA_desc *descA;
real_Double_t t;
int *ipiv, *ipiv2 = NULL;
int i;
int nb = iparam[TIMING_NB];
int m = iparam[TIMING_N];
int n = iparam[TIMING_NRHS];
int check = iparam[TIMING_CHECK];
int lda = m;
PLASMA_sequence *sequence = NULL;
PLASMA_request request = PLASMA_REQUEST_INITIALIZER;
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
PLASMA_Set(PLASMA_INNER_BLOCK_SIZE, iparam[TIMING_IB] );
/* Allocate Data */
A = (PLASMA_Complex32_t *)malloc(lda*n*sizeof(PLASMA_Complex32_t));
AT = (PLASMA_Complex32_t *)malloc(lda*n*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( ( !AT ) || (! A) ) {
printf("Out of Memory \n ");
return -1;
}
/* Initialiaze Data */
LAPACKE_clarnv_work(1, ISEED, lda*n, A);
/* for(i=0; i<n; i++) { */
/* A[i*lda+i] += (float)m; */
/* } */
PLASMA_Desc_Create(&descA, AT, PlasmaComplexFloat, nb, nb, nb*nb, lda, n, 0, 0, m, n);
PLASMA_cLapack_to_Tile((void*)A, lda, descA);
/* Allocate Workspace */
ipiv = (int *)malloc( n*sizeof(int) );
/* Save AT in lapack layout for check */
if ( check ) {
A2 = (PLASMA_Complex32_t *)malloc(lda*n*sizeof(PLASMA_Complex32_t));
ipiv2 = (int *)malloc( n*sizeof(int) );
LAPACKE_clacpy_work(LAPACK_COL_MAJOR,' ', m, n, A, lda, A2, lda);
LAPACKE_cgetrf_work(LAPACK_COL_MAJOR, m, n, A2, lda, ipiv2 );
}
plasma = plasma_context_self();
PLASMA_Sequence_Create(&sequence);
QUARK_Task_Flag_Set(&task_flags, TASK_SEQUENCE, (intptr_t)sequence->quark_sequence);
QUARK_Task_Flag_Set(&task_flags, TASK_THREAD_COUNT, iparam[TIMING_THRDNBR] );
plasma_dynamic_spawn();
CORE_cgetrf_rectil_init();
t = -cWtime();
QUARK_CORE_cgetrf_rectil(plasma->quark, &task_flags,
*descA, AT, descA->mb*descA->nb, ipiv,
sequence, &request,
0, 0,
iparam[TIMING_THRDNBR]);
PLASMA_Sequence_Wait(sequence);
t += cWtime();
*t_ = t;
PLASMA_Sequence_Destroy(sequence);
/* Check the solution */
if ( check )
{
float *work = (float *)malloc(max(m,n)*sizeof(float));
PLASMA_cTile_to_Lapack(descA, (void*)A, lda);
/* Check ipiv */
for(i=0; i<n; i++)
{
if( ipiv[i] != ipiv2[i] ) {
fprintf(stderr, "\nPLASMA (ipiv[%d] = %d, A[%d] = %e) / LAPACK (ipiv[%d] = %d, A[%d] = [%e])\n",
i, ipiv[i], i, crealf(A[ i * lda + i ]),
i, ipiv2[i], i, crealf(A2[ i * lda + i ]));
break;
}
}
dparam[TIMING_ANORM] = LAPACKE_clange_work(LAPACK_COL_MAJOR, lapack_const(PlasmaMaxNorm),
m, n, A, lda, work);
dparam[TIMING_XNORM] = LAPACKE_clange_work(LAPACK_COL_MAJOR, lapack_const(PlasmaMaxNorm),
m, n, A2, lda, work);
dparam[TIMING_BNORM] = 0.0;
CORE_caxpy( m, n, -1.0, A, lda, A2, lda);
dparam[TIMING_RES] = LAPACKE_clange_work(LAPACK_COL_MAJOR, lapack_const(PlasmaMaxNorm),
m, n, A2, lda, work);
free( A2 );
free( ipiv2 );
free( work );
}
/* Deallocate Workspace */
PLASMA_Desc_Destroy(&descA);
free( A );
free( AT );
free( ipiv );
PLASMA_Finalize();
return 0;
}
int main ()
{
int cores = 2;
int N = 10;
int LDA = 10;
int NRHS = 5;
int LDB = 10;
int info;
int info_solution;
int i,j;
int LDAxN = LDA*N;
int LDBxNRHS = LDB*NRHS;
PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*(sizeof*A1));
PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*(sizeof*A2));
PLASMA_Complex32_t *B1 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*(sizeof*B1));
PLASMA_Complex32_t *B2 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*(sizeof*B2));
PLASMA_Complex32_t *L;
int *IPIV;
/* Check if unable to allocate memory */
if ((!A1)||(!A2)||(!B1)||(!B2)){
printf("Out of Memory \n ");
exit(0);
}
/*Plasma Initialize*/
PLASMA_Init(cores);
printf("-- PLASMA is initialized to run on %d cores. \n",cores);
/* Initialize A1 and A2 Matrix */
LAPACKE_clarnv_work(IONE, ISEED, LDAxN, A1);
for ( i = 0; i < N; i++)
for ( j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i];
/* Initialize B1 and B2 */
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for ( i = 0; i < N; i++)
for ( j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i];
/* PLASMA CGESV */
info = PLASMA_Alloc_Workspace_cgesv_incpiv(N, &L, &IPIV);
info = PLASMA_cgesv_incpiv(N, NRHS, A2, LDA, L, IPIV, B2, LDB);
/* Check the factorization and the solution */
info_solution = check_solution(N, NRHS, A1, LDA, B1, B2, LDB);
if ((info_solution != 0)|(info != 0))
printf("-- Error in CGESV example ! \n");
else
printf("-- Run of CGESV example successful ! \n");
free(A1); free(A2); free(B1); free(B2); free(IPIV); free(L);
PLASMA_Finalize();
exit(0);
}
static int
RunTest(int *iparam, float *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *AT, *bT, *x;
PLASMA_Complex32_t *A = NULL;
PLASMA_Complex32_t *b = NULL;
PLASMA_desc *descA, *descB;
real_Double_t t;
int *piv;
int n = iparam[TIMING_N];
int nb = iparam[TIMING_NB];
int nrhs = iparam[TIMING_NRHS];
int check = iparam[TIMING_CHECK];
int lda = n;
int ldb = n;
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
PLASMA_Set(PLASMA_INNER_BLOCK_SIZE, iparam[TIMING_IB] );
/* } else { */
/* PLASMA_Get(PLASMA_TILE_SIZE, &iparam[TIMING_NB] ); */
/* PLASMA_Get(PLASMA_INNER_BLOCK_SIZE, &iparam[TIMING_IB] ); */
/* } */
/* Allocate Data */
AT = (PLASMA_Complex32_t *)malloc(lda*n *sizeof(PLASMA_Complex32_t));
bT = (PLASMA_Complex32_t *)malloc(ldb*nrhs*sizeof(PLASMA_Complex32_t));
piv = (int *)malloc( n*sizeof(int));
/* Check if unable to allocate memory */
if ( (!AT) || (!bT) || (!piv) ) {
printf("Out of Memory \n ");
return -1;
}
/* Initialize AT and bT for Symmetric Positif Matrix */
PLASMA_Desc_Create(&descA, AT, PlasmaComplexFloat, nb, nb, nb*nb, lda, n, 0, 0, n, n);
PLASMA_Desc_Create(&descB, bT, PlasmaComplexFloat, nb, nb, nb*nb, ldb, nrhs, 0, 0, n, nrhs);
LAPACKE_clarnv_work(1, ISEED, lda*n, AT);
LAPACKE_clarnv_work(1, ISEED, ldb*nrhs, bT);
/* Save AT and bT in lapack layout for check */
if ( check ) {
A = (PLASMA_Complex32_t *)malloc(lda*n *sizeof(PLASMA_Complex32_t));
b = (PLASMA_Complex32_t *)malloc(ldb*nrhs*sizeof(PLASMA_Complex32_t));
PLASMA_cTile_to_Lapack(descA, (void*)A, lda);
PLASMA_cTile_to_Lapack(descB, (void*)b, ldb);
}
t = -cWtime();
PLASMA_cgesv_Tile( descA, piv, descB );
t += cWtime();
*t_ = t;
/* Check the solution */
if ( check )
{
x = (PLASMA_Complex32_t *)malloc(ldb*nrhs *sizeof(PLASMA_Complex32_t));
PLASMA_cTile_to_Lapack(descB, (void*)x, n);
dparam[TIMING_RES] = c_check_solution(n, n, nrhs, A, lda, b, x, ldb,
&(dparam[TIMING_ANORM]), &(dparam[TIMING_BNORM]),
&(dparam[TIMING_XNORM]));
free(A); free(b); free(x);
}
PLASMA_Desc_Destroy(&descA);
PLASMA_Desc_Destroy(&descB);
free( AT ); free( bT );
free( piv );
PLASMA_Finalize();
return 0;
}
static int
RunTest(int *iparam, _PREC *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *A = NULL, *AT;
PLASMA_desc *descA;
real_Double_t t;
int n = iparam[TIMING_N];
int nb = iparam[TIMING_NB];
int check = iparam[TIMING_CHECK];
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
/* } */
n = ((n % nb) == 0) ? (n / nb) * nb : ((n / nb) + 1) * nb ;
dparam[TIMING_ANORM] = (_PREC)n;
/* Allocate Data */
AT = (PLASMA_Complex32_t *)malloc(n*n*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( (!AT) ) {
printf("Out of Memory \n ");
exit(0);
}
/* Initialiaze Data */
PLASMA_Desc_Create(&descA, AT, PlasmaComplexFloat, nb, nb, nb*nb, n, n, 0, 0, n, n);
LAPACKE_clarnv_work(1, ISEED, n*n, AT);
/* Save A and b */
if (check) {
A = (PLASMA_Complex32_t *)malloc(n*n*sizeof(PLASMA_Complex32_t));
LAPACKE_clacpy_work(LAPACK_COL_MAJOR, lapack_const(PlasmaUpperLower), n, n, AT, n, A, n);
}
t = -cWtime();
PLASMA_Lapack_to_Tile( (void *)A, n, descA);
t += cWtime();
*t_ = t;
/* Check the solution */
if (check)
{
dparam[TIMING_RES] = (_PREC)c_check_conversion(n, n, n, 1, nb, nb, A, AT, map_CM, map_CCRB);
free(A);
}
PLASMA_Desc_Destroy(&descA);
free( AT );
PLASMA_Finalize();
return 0;
}
int main ()
{
int cores = 2;
int M = 15;
int N = 10;
int LDA = 15;
int NRHS = 5;
int LDB = 15;
int info;
int info_solution;
int i,j;
int LDAxN = LDA*N;
int LDBxNRHS = LDB*NRHS;
PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B1 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B2 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *T;
/* Check if unable to allocate memory */
if ((!A1)||(!A2)||(!B1)||(!B2)){
printf("Out of Memory \n ");
exit(0);
}
/* Plasma Initialization */
PLASMA_Init(cores);
printf("-- PLASMA is initialized to run on %d cores. \n",cores);
/* Allocate T */
PLASMA_Alloc_Workspace_cgeqrf(M, N, &T);
/* Initialize A1 and A2 */
LAPACKE_clarnv_work(IONE, ISEED, LDAxN, A1);
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i] ;
/* Initialize B1 and B2 */
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for (i = 0; i < M; i++)
for (j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i] ;
/* Factorization QR of the matrix A2 */
info = PLASMA_cgeqrf(M, N, A2, LDA, T);
/* Solve the problem */
info = PLASMA_cgeqrs(M, N, NRHS, A2, LDA, T, B2, LDB);
/* Check the solution */
info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB);
if ((info_solution != 0)|(info != 0))
printf("-- Error in CGEQRS example ! \n");
else
printf("-- Run of CGEQRS example successful ! \n");
free(A1); free(A2); free(B1); free(B2); free(T);
PLASMA_Finalize();
exit(0);
}
static int
RunTest(int *iparam, float *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *A, *Acpy = NULL, *L, *b, *x;
real_Double_t t;
int *piv;
int n = iparam[TIMING_N];
int nrhs = iparam[TIMING_NRHS];
int check = iparam[TIMING_CHECK];
int lda = n;
int ldb = n;
/* Allocate Data */
A = (PLASMA_Complex32_t *)malloc(lda*n*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( !A ){
printf("Out of Memory \n ");
exit(0);
}
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
PLASMA_Set(PLASMA_INNER_BLOCK_SIZE, iparam[TIMING_IB] );
/* } else { */
/* PLASMA_Get(PLASMA_TILE_SIZE, &iparam[TIMING_NB] ); */
/* PLASMA_Get(PLASMA_INNER_BLOCK_SIZE, &iparam[TIMING_IB] ); */
/* } */
/* Initialiaze Data */
LAPACKE_clarnv_work(1, ISEED, n*lda, A);
/* Allocate Workspace */
PLASMA_Alloc_Workspace_cgesv_incpiv(n, &L, &piv);
/* Save AT in lapack layout for check */
if ( check ) {
Acpy = (PLASMA_Complex32_t *)malloc(lda*n*sizeof(PLASMA_Complex32_t));
LAPACKE_clacpy_work(LAPACK_COL_MAJOR,' ', n, n, A, lda, Acpy, lda);
}
t = -cWtime();
PLASMA_cgetrf_incpiv( n, n, A, lda, L, piv );
t += cWtime();
*t_ = t;
/* Check the solution */
if ( check )
{
b = (PLASMA_Complex32_t *)malloc(ldb*nrhs *sizeof(PLASMA_Complex32_t));
x = (PLASMA_Complex32_t *)malloc(ldb*nrhs *sizeof(PLASMA_Complex32_t));
LAPACKE_clarnv_work(1, ISEED, ldb*nrhs, x);
LAPACKE_clacpy_work(LAPACK_COL_MAJOR,' ', n, nrhs, x, ldb, b, ldb);
PLASMA_cgetrs_incpiv( PlasmaNoTrans, n, nrhs, A, lda, L, piv, x, ldb );
dparam[TIMING_RES] = c_check_solution(n, n, nrhs, Acpy, lda, b, x, ldb,
&(dparam[TIMING_ANORM]), &(dparam[TIMING_BNORM]),
&(dparam[TIMING_XNORM]));
free( Acpy ); free( b ); free( x );
}
free( A );
free( L );
free( piv );
PLASMA_Finalize();
return 0;
}
int testing_cgels(int argc, char **argv)
{
int mode = 0;
if ( argc < 1 ){
goto usage;
} else {
mode = atoi(argv[0]);
}
/* Check for number of arguments*/
if ( ((mode == 0) && (argc != 6)) ||
((mode != 0) && (argc != 7)) ){
usage:
USAGE("GELS", "MODE M N LDA NRHS LDB [RH]",
" - MODE : 0: flat, 1: tree (RH needed)\n"
" - M : number of rows of the matrix A\n"
" - N : number of columns of the matrix A\n"
" - LDA : leading dimension of the matrix A\n"
" - NRHS : number of RHS\n"
" - LDB : leading dimension of the matrix B\n"
" - RH : Size of each subdomains\n");
return -1;
}
int M = atoi(argv[1]);
int N = atoi(argv[2]);
int LDA = atoi(argv[3]);
int NRHS = atoi(argv[4]);
int LDB = atoi(argv[5]);
int rh;
int K = min(M, N);
float eps;
int info_ortho, info_solution, info_factorization;
int i,j;
int LDAxN = LDA*N;
int LDBxNRHS = LDB*NRHS;
PLASMA_Complex32_t *A1 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *A2 = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B1 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B2 = (PLASMA_Complex32_t *)malloc(LDB*NRHS*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *Q = (PLASMA_Complex32_t *)malloc(LDA*N*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *T;
/* Check if unable to allocate memory */
if ((!A1)||(!A2)||(!B1)||(!B2)||(!Q)){
printf("Out of Memory \n ");
return -2;
}
if ( mode ) {
rh = atoi(argv[6]);
PLASMA_Set(PLASMA_HOUSEHOLDER_MODE, PLASMA_TREE_HOUSEHOLDER);
PLASMA_Set(PLASMA_HOUSEHOLDER_SIZE, rh);
}
PLASMA_Alloc_Workspace_cgels(M, N, &T);
eps = BLAS_sfpinfo( blas_eps );
/*----------------------------------------------------------
* TESTING CGELS
*/
/* Initialize A1 and A2 */
LAPACKE_clarnv_work(IONE, ISEED, LDAxN, A1);
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i] ;
/* Initialize B1 and B2 */
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for (i = 0; i < M; i++)
for (j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i] ;
memset((void*)Q, 0, LDA*N*sizeof(PLASMA_Complex32_t));
for (i = 0; i < K; i++)
Q[LDA*i+i] = 1.0;
/* PLASMA CGELS */
PLASMA_cgels(PlasmaNoTrans, M, N, NRHS, A2, LDA, T, B2, LDB);
/* PLASMA CGELS */
if (M >= N)
/* Building the economy-size Q */
PLASMA_cungqr(M, N, K, A2, LDA, T, Q, LDA);
else
/* Building the economy-size Q */
PLASMA_cunglq(M, N, K, A2, LDA, T, Q, LDA);
printf("\n");
printf("------ TESTS FOR PLASMA CGELS ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
/* Check the orthogonality, factorization and the solution */
info_ortho = check_orthogonality(M, N, LDA, Q, eps);
info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);
if ((info_solution == 0)&(info_factorization == 0)&(info_ortho == 0)) {
printf("***************************************************\n");
printf(" ---- TESTING CGELS ...................... PASSED !\n");
printf("***************************************************\n");
}
else {
printf("************************************************\n");
printf(" - TESTING CGELS ... FAILED !\n");
printf("************************************************\n");
}
/*-------------------------------------------------------------
* TESTING CGEQRF + CGEQRS or CGELQF + CGELQS
*/
/* Initialize A1 and A2 */
LAPACKE_clarnv_work(IONE, ISEED, LDAxN, A1);
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i];
/* Initialize B1 and B2 */
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for (i = 0; i < M; i++)
for (j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i];
memset((void*)Q, 0, LDA*N*sizeof(PLASMA_Complex32_t));
for (i = 0; i < K; i++)
Q[LDA*i+i] = 1.0;
if (M >= N) {
printf("\n");
printf("------ TESTS FOR PLASMA CGEQRF + CGEQRS ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n", eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
/* Plasma routines */
PLASMA_cgeqrf(M, N, A2, LDA, T);
PLASMA_cungqr(M, N, K, A2, LDA, T, Q, LDA);
PLASMA_cgeqrs(M, N, NRHS, A2, LDA, T, B2, LDB);
/* Check the orthogonality, factorization and the solution */
info_ortho = check_orthogonality(M, N, LDA, Q, eps);
info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);
if ((info_solution == 0)&(info_factorization == 0)&(info_ortho == 0)) {
printf("***************************************************\n");
printf(" ---- TESTING CGEQRF + CGEQRS ............ PASSED !\n");
printf("***************************************************\n");
}
else{
printf("***************************************************\n");
printf(" - TESTING CGEQRF + CGEQRS ... FAILED !\n");
printf("***************************************************\n");
}
}
else {
printf("\n");
printf("------ TESTS FOR PLASMA CGELQF + CGELQS ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n", eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
/* Plasma routines */
PLASMA_cgelqf(M, N, A2, LDA, T);
PLASMA_cunglq(M, N, K, A2, LDA, T, Q, LDA);
PLASMA_cgelqs(M, N, NRHS, A2, LDA, T, B2, LDB);
/* Check the orthogonality, factorization and the solution */
info_ortho = check_orthogonality(M, N, LDA, Q, eps);
info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);
if ( (info_solution == 0) & (info_factorization == 0) & (info_ortho == 0) ) {
printf("***************************************************\n");
printf(" ---- TESTING CGELQF + CGELQS ............ PASSED !\n");
printf("***************************************************\n");
}
else {
printf("***************************************************\n");
printf(" - TESTING CGELQF + CGELQS ... FAILED !\n");
printf("***************************************************\n");
}
}
/*----------------------------------------------------------
* TESTING CGEQRF + ZORMQR + CTRSM
*/
/* Initialize A1 and A2 */
LAPACKE_clarnv_work(IONE, ISEED, LDAxN, A1);
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
A2[LDA*j+i] = A1[LDA*j+i];
/* Initialize B1 and B2 */
memset(B2, 0, LDB*NRHS*sizeof(PLASMA_Complex32_t));
LAPACKE_clarnv_work(IONE, ISEED, LDBxNRHS, B1);
for (i = 0; i < M; i++)
for (j = 0; j < NRHS; j++)
B2[LDB*j+i] = B1[LDB*j+i];
/* PLASMA CGEQRF+ CUNMQR + CTRSM */
memset((void*)Q, 0, LDA*N*sizeof(PLASMA_Complex32_t));
for (i = 0; i < K; i++)
Q[LDA*i+i] = 1.0;
if (M >= N) {
printf("\n");
printf("------ TESTS FOR PLASMA CGEQRF + CUNMQR + CTRSM ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
PLASMA_cgeqrf(M, N, A2, LDA, T);
PLASMA_cungqr(M, N, K, A2, LDA, T, Q, LDA);
PLASMA_cunmqr(PlasmaLeft, PlasmaConjTrans, M, NRHS, N, A2, LDA, T, B2, LDB);
PLASMA_ctrsm(PlasmaLeft, PlasmaUpper, PlasmaNoTrans, PlasmaNonUnit, N, NRHS, 1.0, A2, LDA, B2, LDB);
}
else {
printf("\n");
printf("------ TESTS FOR PLASMA CGELQF + CUNMLQ + CTRSM ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 60.\n");
PLASMA_cgelqf(M, N, A2, LDA, T);
PLASMA_ctrsm(PlasmaLeft, PlasmaLower, PlasmaNoTrans, PlasmaNonUnit, M, NRHS, 1.0, A2, LDA, B2, LDB);
PLASMA_cunglq(M, N, K, A2, LDA, T, Q, LDA);
PLASMA_cunmlq(PlasmaLeft, PlasmaConjTrans, N, NRHS, M, A2, LDA, T, B2, LDB);
}
/* Check the orthogonality, factorization and the solution */
info_ortho = check_orthogonality(M, N, LDA, Q, eps);
info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);
if ( (info_solution == 0) & (info_factorization == 0) & (info_ortho == 0) ) {
if (M >= N) {
printf("***************************************************\n");
printf(" ---- TESTING CGEQRF + CUNMQR + CTRSM .... PASSED !\n");
printf("***************************************************\n");
}
else {
printf("***************************************************\n");
printf(" ---- TESTING CGELQF + CTRSM + CUNMLQ .... PASSED !\n");
printf("***************************************************\n");
}
}
else {
if (M >= N) {
printf("***************************************************\n");
printf(" - TESTING CGEQRF + CUNMQR + CTRSM ... FAILED !\n");
printf("***************************************************\n");
}
else {
printf("***************************************************\n");
printf(" - TESTING CGELQF + CTRSM + CUNMLQ ... FAILED !\n");
printf("***************************************************\n");
}
}
free(A1); free(A2); free(B1); free(B2); free(Q); free(T);
return 0;
}
int testing_csymm(int argc, char **argv)
{
/* Check for number of arguments*/
if ( argc != 7 ){
USAGE("SYMM", "alpha beta M N K LDA LDB LDC",
" - alpha : alpha coefficient \n"
" - beta : beta coefficient \n"
" - M : number of rows of matrices A and C \n"
" - N : number of columns of matrices B and C \n"
" - LDA : leading dimension of matrix A \n"
" - LDB : leading dimension of matrix B \n"
" - LDC : leading dimension of matrix C\n");
return -1;
}
PLASMA_Complex32_t alpha = (PLASMA_Complex32_t) atol(argv[0]);
PLASMA_Complex32_t beta = (PLASMA_Complex32_t) atol(argv[1]);
int M = atoi(argv[2]);
int N = atoi(argv[3]);
int LDA = atoi(argv[4]);
int LDB = atoi(argv[5]);
int LDC = atoi(argv[6]);
int MNmax = max(M, N);
int MminusOne = MNmax - 1;
float eps;
int info_solution;
int i, j, s, u, info;
int LDAxM = LDA*max(M, N);
int LDBxN = LDB*N;
int LDCxN = LDC*N;
PLASMA_Complex32_t *A = (PLASMA_Complex32_t *)malloc(LDAxM*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *B = (PLASMA_Complex32_t *)malloc(LDBxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *C = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *Cinit = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *Cfinal = (PLASMA_Complex32_t *)malloc(LDCxN*sizeof(PLASMA_Complex32_t));
PLASMA_Complex32_t *WORK = (PLASMA_Complex32_t *)malloc(2*LDC*sizeof(PLASMA_Complex32_t));
float *D = (float *) malloc(LDC *sizeof(float));
/* Check if unable to allocate memory */
if ((!A)||(!B)||(!Cinit)||(!Cfinal)){
printf("Out of Memory \n ");
return -2;
}
eps = LAPACKE_slamch_work('e');
printf("\n");
printf("------ TESTS FOR PLASMA CSYMM ROUTINE ------- \n");
printf(" Size of the Matrix %d by %d\n", M, N);
printf("\n");
printf(" The matrix A is randomly generated for each test.\n");
printf("============\n");
printf(" The relative machine precision (eps) is to be %e \n",eps);
printf(" Computational tests pass if scaled residuals are less than 10.\n");
/*----------------------------------------------------------
* TESTING CSYMM
*/
/* Initialize A */
LAPACKE_slarnv_work(IONE, ISEED, LDC, D);
claghe(&MNmax, &MminusOne, D, A, &LDA, ISEED, WORK, &info);
free(D); free(WORK);
/* Initialize B */
LAPACKE_clarnv_work(IONE, ISEED, LDBxN, B);
/* Initialize C */
LAPACKE_clarnv_work(IONE, ISEED, LDCxN, C);
for (s=0; s<2; s++) {
for (u=0; u<2; u++) {
/* Initialize Cinit / Cfinal */
for ( i = 0; i < M; i++)
for ( j = 0; j < N; j++)
Cinit[LDC*j+i] = C[LDC*j+i];
for ( i = 0; i < M; i++)
for ( j = 0; j < N; j++)
Cfinal[LDC*j+i] = C[LDC*j+i];
/* PLASMA CSYMM */
PLASMA_csymm(side[s], uplo[u], M, N, alpha, A, LDA, B, LDB, beta, Cfinal, LDC);
/* Check the solution */
info_solution = check_solution(side[s], uplo[u], M, N, alpha, A, LDA, B, LDB, beta, Cinit, Cfinal, LDC);
if (info_solution == 0) {
printf("***************************************************\n");
printf(" ---- TESTING CSYMM (%5s, %5s) ....... PASSED !\n", sidestr[s], uplostr[u]);
printf("***************************************************\n");
}
else {
printf("************************************************\n");
printf(" - TESTING CSYMM (%s, %s) ... FAILED !\n", sidestr[s], uplostr[u]);
printf("************************************************\n");
}
}
}
free(A); free(B); free(C);
free(Cinit); free(Cfinal);
return 0;
}
static int
RunTest(int *iparam, float *dparam, real_Double_t *t_)
{
PLASMA_Complex32_t *AT, *BT, *CT;
PLASMA_Complex32_t *A = NULL, *B = NULL, *C1 = NULL, *C2 = NULL;
PLASMA_Complex32_t alpha, beta;
PLASMA_desc *descA, *descB, *descC;
real_Double_t t;
int nb, nb2, nt;
int n = iparam[TIMING_N];
int check = iparam[TIMING_CHECK];
int lda = n;
/* Allocate Data */
/* Initialize Plasma */
PLASMA_Init( iparam[TIMING_THRDNBR] );
if ( iparam[TIMING_SCHEDULER] )
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_DYNAMIC_SCHEDULING );
else
PLASMA_Set(PLASMA_SCHEDULING_MODE, PLASMA_STATIC_SCHEDULING );
/*if ( !iparam[TIMING_AUTOTUNING] ) {*/
PLASMA_Disable(PLASMA_AUTOTUNING);
PLASMA_Set(PLASMA_TILE_SIZE, iparam[TIMING_NB] );
/* } */
/* } else { */
/* PLASMA_Get(PLASMA_TILE_SIZE, &iparam[TIMING_NB] ); */
/* } */
nb = iparam[TIMING_NB];
nb2 = nb * nb;
nt = n / nb + ((n % nb == 0) ? 0 : 1);
AT = (PLASMA_Complex32_t *)malloc(nt*nt*nb2*sizeof(PLASMA_Complex32_t));
BT = (PLASMA_Complex32_t *)malloc(nt*nt*nb2*sizeof(PLASMA_Complex32_t));
CT = (PLASMA_Complex32_t *)malloc(nt*nt*nb2*sizeof(PLASMA_Complex32_t));
/* Check if unable to allocate memory */
if ( (!AT) || (!BT) || (!CT) ) {
printf("Out of Memory \n ");
exit(0);
}
/* Initialiaze Data */
LAPACKE_clarnv_work(1, ISEED, 1, &alpha);
LAPACKE_clarnv_work(1, ISEED, 1, &beta);
LAPACKE_clarnv_work(1, ISEED, nt*nt*nb2, AT);
LAPACKE_clarnv_work(1, ISEED, nt*nt*nb2, BT);
LAPACKE_clarnv_work(1, ISEED, nt*nt*nb2, CT);
/* Initialize AT and bT for Symmetric Positif Matrix */
PLASMA_Desc_Create(&descA, AT, PlasmaComplexFloat, nb, nb, nb*nb, n, n, 0, 0, n, n);
PLASMA_Desc_Create(&descB, BT, PlasmaComplexFloat, nb, nb, nb*nb, n, n, 0, 0, n, n);
PLASMA_Desc_Create(&descC, CT, PlasmaComplexFloat, nb, nb, nb*nb, n, n, 0, 0, n, n);
if (check)
{
C2 = (PLASMA_Complex32_t *)malloc(n*lda*sizeof(PLASMA_Complex32_t));
PLASMA_Tile_to_Lapack(descC, (void*)C2, n);
}
t = -cWtime();
PLASMA_cgemm_Tile( PlasmaNoTrans, PlasmaNoTrans, alpha, descA, descB, beta, descC );
t += cWtime();
*t_ = t;
/* Check the solution */
if (check)
{
A = (PLASMA_Complex32_t *)malloc(n*lda*sizeof(PLASMA_Complex32_t));
PLASMA_Tile_to_Lapack(descA, (void*)A, n);
free(AT);
B = (PLASMA_Complex32_t *)malloc(n*lda*sizeof(PLASMA_Complex32_t));
PLASMA_Tile_to_Lapack(descB, (void*)B, n);
free(BT);
C1 = (PLASMA_Complex32_t *)malloc(n*lda*sizeof(PLASMA_Complex32_t));
PLASMA_Tile_to_Lapack(descC, (void*)C1, n);
free(CT);
dparam[TIMING_RES] = c_check_gemm( PlasmaNoTrans, PlasmaNoTrans, n, n, n,
alpha, A, lda, B, lda, beta, C1, C2, lda,
&(dparam[TIMING_ANORM]), &(dparam[TIMING_BNORM]),
&(dparam[TIMING_XNORM]));
free(C2);
}
else {
free( AT );
free( BT );
free( CT );
}
PLASMA_Desc_Destroy(&descA);
PLASMA_Desc_Destroy(&descB);
PLASMA_Desc_Destroy(&descC);
PLASMA_Finalize();
return 0;
}