From 41f4196d6f24fe11c707a810424bc3f4d3b7c1f7 Mon Sep 17 00:00:00 2001
From: Mathieu Faverge <mathieu.faverge@inria.fr>
Date: Wed, 11 Mar 2020 10:18:33 +0100
Subject: [PATCH] Add an mtxfmt parameter to switch between the different
allocation mode (Fix issue #94)
---
testing/chameleon_ztesting.c | 1 +
testing/testing_zgeadd.c | 27 +++++++++++-----------
testing/testing_zgelqf.c | 25 ++++++++++----------
testing/testing_zgelqf_hqr.c | 33 +++++++++++++-------------
testing/testing_zgelqs.c | 31 +++++++++++++------------
testing/testing_zgels.c | 39 ++++++++++++++++---------------
testing/testing_zgels_hqr.c | 11 +++++----
testing/testing_zgemm.c | 11 +++++----
testing/testing_zgeqrf.c | 25 ++++++++++----------
testing/testing_zgeqrf_hqr.c | 33 +++++++++++++-------------
testing/testing_zgeqrs.c | 31 +++++++++++++------------
testing/testing_zgesv.c | 25 ++++++++++----------
testing/testing_zgetrf.c | 19 +++++++--------
testing/testing_zgetrs.c | 25 ++++++++++----------
testing/testing_zhemm.c | 45 ++++++++++++++++++------------------
testing/testing_zher2k.c | 29 ++++++++++++-----------
testing/testing_zherk.c | 37 ++++++++++++++---------------
testing/testing_zlacpy.c | 25 ++++++++++----------
testing/testing_zlange.c | 5 ++--
testing/testing_zlanhe.c | 5 ++--
testing/testing_zlansy.c | 5 ++--
testing/testing_zlantr.c | 5 ++--
testing/testing_zlascal.c | 25 ++++++++++----------
testing/testing_zlauum.c | 19 +++++++--------
testing/testing_zposv.c | 27 +++++++++++-----------
testing/testing_zpotrf.c | 19 +++++++--------
testing/testing_zpotri.c | 19 +++++++--------
testing/testing_zpotrs.c | 27 +++++++++++-----------
testing/testing_zsymm.c | 45 ++++++++++++++++++------------------
testing/testing_zsyr2k.c | 29 ++++++++++++-----------
testing/testing_zsyrk.c | 25 ++++++++++----------
testing/testing_zsysv.c | 27 +++++++++++-----------
testing/testing_zsytrf.c | 19 +++++++--------
testing/testing_zsytrs.c | 27 +++++++++++-----------
testing/testing_ztradd.c | 23 +++++++++---------
testing/testing_ztrmm.c | 37 ++++++++++++++---------------
testing/testing_ztrsm.c | 37 ++++++++++++++---------------
testing/testing_ztrtri.c | 21 +++++++++--------
testing/testing_zunglq.c | 27 +++++++++++-----------
testing/testing_zunglq_hqr.c | 35 ++++++++++++++--------------
testing/testing_zungqr.c | 27 +++++++++++-----------
testing/testing_zungqr_hqr.c | 35 ++++++++++++++--------------
testing/testing_zunmlq.c | 37 ++++++++++++++---------------
testing/testing_zunmlq_hqr.c | 9 ++++----
testing/testing_zunmqr.c | 37 ++++++++++++++---------------
testing/testing_zunmqr_hqr.c | 9 ++++----
46 files changed, 590 insertions(+), 544 deletions(-)
diff --git a/testing/chameleon_ztesting.c b/testing/chameleon_ztesting.c
index 93fc4472e..8f05493dd 100644
--- a/testing/chameleon_ztesting.c
+++ b/testing/chameleon_ztesting.c
@@ -40,6 +40,7 @@ static parameter_t parameters[] = {
{ "niter", "Perform multiple iteration per test", 'l', PARAM_OPTION, 1, 0, TestValInt, {1}, NULL, pread_int, sprint_int },
{ "trace", "Enable the trace generation", -30, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
{ "nowarmup", "Disable the warmup run to load libraries", -31, PARAM_OPTION, 0, 0, TestValInt, {0}, NULL, pread_int, sprint_int },
+ { "mtxfmt", "Change the way the matrix is stored (0: global, 1: tiles, 2: OOC)", -32, PARAM_OPTION | PARAM_INPUT | PARAM_OUTPUT, 1, 6, TestValInt, {0}, NULL, pread_int, sprint_int },
{ NULL, "Machine parameters", 0, PARAM_OPTION, 0, 0, 0, {0}, NULL, NULL, NULL },
{ "threads", "Number of CPU workers per node", 't', PARAM_OPTION | PARAM_OUTPUT, 1, 7, TestValInt, {-1}, NULL, pread_int, sprint_int },
diff --git a/testing/testing_zgeadd.c b/testing/testing_zgeadd.c
index 00358df0c..becf3433e 100644
--- a/testing/testing_zgeadd.c
+++ b/testing/testing_zgeadd.c
@@ -42,16 +42,17 @@ testing_zgeadd( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB;
/* Read arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? M : N ) );
- int LDB = run_arg_get_int( args, "LDB", M );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? M : N ) );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
CHAMELEON_Complex64_t alpha = testing_zalea();
CHAMELEON_Complex64_t beta = testing_zalea();
cham_fixdbl_t t, gflops;
@@ -73,9 +74,9 @@ testing_zgeadd( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
/* Fill the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -106,7 +107,7 @@ testing_zgeadd( run_arg_list_t *args, int check )
}
testing_t test_zgeadd;
-const char *zgeadd_params[] = { "nb", "trans", "m", "n", "lda", "ldb",
+const char *zgeadd_params[] = { "mtxfmt", "nb", "trans", "m", "n", "lda", "ldb",
"alpha", "beta", "seedA", "seedB", NULL };
const char *zgeadd_output[] = { NULL };
const char *zgeadd_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgelqf.c b/testing/testing_zgelqf.c
index db11f2d8f..ba0f5c20a 100644
--- a/testing/testing_zgelqf.c
+++ b/testing/testing_zgelqf.c
@@ -27,15 +27,16 @@ testing_zgelqf( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int RH = run_arg_get_int( args, "qra", 4 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int RH = run_arg_get_int( args, "qra", 4 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgelqf( M, N );
@@ -52,7 +53,7 @@ testing_zgelqf( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -72,7 +73,7 @@ testing_zgelqf( run_arg_list_t *args, int check )
CHAM_desc_t *descA0 = CHAMELEON_Desc_Copy( descA, NULL );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, N, N, 0, 0, N, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, N, N, 0, 0, N, N, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zunglq_Tile( descA, descT, descQ );
@@ -91,7 +92,7 @@ testing_zgelqf( run_arg_list_t *args, int check )
}
testing_t test_zgelqf;
-const char *zgelqf_params[] = { "nb", "ib", "m", "n", "lda", "qra", "seedA", NULL };
+const char *zgelqf_params[] = { "mtxfmt", "nb","ib", "m", "n", "lda", "qra", "seedA", NULL };
const char *zgelqf_output[] = { NULL };
const char *zgelqf_outchk[] = { "||A||", "||I-QQ'||", "||A-fact(A)||", "RETURN", NULL };
diff --git a/testing/testing_zgelqf_hqr.c b/testing/testing_zgelqf_hqr.c
index a5b3d57a3..02ec329cc 100644
--- a/testing/testing_zgelqf_hqr.c
+++ b/testing/testing_zgelqf_hqr.c
@@ -27,19 +27,20 @@ testing_zgelqf_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int qr_a = run_arg_get_int( args, "qra", -1 );
- int qr_p = run_arg_get_int( args, "qrp", -1 );
- int llvl = run_arg_get_int( args, "llvl", -1 );
- int hlvl = run_arg_get_int( args, "hlvl", -1 );
- int domino = run_arg_get_int( args, "domino", -1 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int qr_a = run_arg_get_int( args, "qra", -1 );
+ int qr_p = run_arg_get_int( args, "qrp", -1 );
+ int llvl = run_arg_get_int( args, "llvl", -1 );
+ int hlvl = run_arg_get_int( args, "hlvl", -1 );
+ int domino = run_arg_get_int( args, "domino", -1 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgelqf( M, N );
@@ -51,7 +52,7 @@ testing_zgelqf_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -80,7 +81,7 @@ testing_zgelqf_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA0 = CHAMELEON_Desc_Copy( descA, NULL );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, N, N, 0, 0, N, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, N, N, 0, 0, N, N, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zunglq_param_Tile( &qrtree, descA, descTS, descTT, descQ );
@@ -101,7 +102,7 @@ testing_zgelqf_hqr( run_arg_list_t *args, int check )
}
testing_t test_zgelqf_hqr;
-const char *zgelqf_hqr_params[] = { "nb", "ib", "m", "n", "lda", "qra",
+const char *zgelqf_hqr_params[] = { "mtxfmt", "nb", "ib", "m", "n", "lda", "qra",
"qrp", "llvl", "hlvl", "domino", "seedA", NULL };
const char *zgelqf_hqr_output[] = { NULL };
const char *zgelqf_hqr_outchk[] = { "||A||", "||I-QQ'||", "||A-fact(A)||", "RETURN", NULL };
diff --git a/testing/testing_zgelqs.c b/testing/testing_zgelqs.c
index 3b9d23bd5..4cad8cdd7 100644
--- a/testing/testing_zgelqs.c
+++ b/testing/testing_zgelqs.c
@@ -35,18 +35,19 @@ testing_zgelqs( run_arg_list_t *args, int check )
CHAM_desc_t *descA1, *descA2, *descB1, *descB2, *descT, *descQ, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", M );
- int LDB = run_arg_get_int( args, "LDB", M );
- int RH = run_arg_get_int( args, "qra", 0 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int RH = run_arg_get_int( args, "qra", 0 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgelqs();
@@ -70,9 +71,9 @@ testing_zgelqs( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, K, 0, 0, M, K, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, K, 0, 0, M, K, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -108,7 +109,7 @@ testing_zgelqs( run_arg_list_t *args, int check )
}
testing_t test_zgelqs;
-const char *zgelqs_params[] = { "nb", "ib", "m", "n", "k", "lda",
+const char *zgelqs_params[] = { "mtxfmt", "nb", "ib", "m", "n", "k", "lda",
"ldb", "qra", "seedA", "seedB", NULL };
const char *zgelqs_output[] = { NULL };
const char *zgelqs_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgels.c b/testing/testing_zgels.c
index 6e78dae1b..9cb387462 100644
--- a/testing/testing_zgels.c
+++ b/testing/testing_zgels.c
@@ -39,20 +39,21 @@ testing_zgels( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX, *descT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int maxMN = chameleon_max( M, N );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", M );
- int LDB = run_arg_get_int( args, "LDB", maxMN );
- int RH = run_arg_get_int( args, "qra", 4 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int maxMN = chameleon_max( M, N );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int LDB = run_arg_get_int( args, "LDB", maxMN );
+ int RH = run_arg_get_int( args, "qra", 4 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgels( trans, M, N, NRHS );
@@ -72,9 +73,9 @@ testing_zgels( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -94,9 +95,9 @@ testing_zgels( run_arg_list_t *args, int check )
CHAM_desc_t *subX, *subB;
CHAMELEON_Desc_Create(
- &descA0, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA0, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zplrnt_Tile( descB, seedB );
@@ -128,7 +129,7 @@ testing_zgels( run_arg_list_t *args, int check )
}
testing_t test_zgels;
-const char *zgels_params[] = { "nb", "ib", "trans", "m", "n", "k",
+const char *zgels_params[] = { "mtxfmt", "nb", "ib", "trans", "m", "n", "k",
"lda", "ldb", "qra", "seedA", "seedB", NULL };
const char *zgels_output[] = { NULL };
const char *zgels_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgels_hqr.c b/testing/testing_zgels_hqr.c
index 3bf679add..f457a006f 100644
--- a/testing/testing_zgels_hqr.c
+++ b/testing/testing_zgels_hqr.c
@@ -39,6 +39,7 @@ testing_zgels_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX, *descTS, *descTT;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int ib = run_arg_get_int( args, "ib", 48 );
int P = parameters_getvalue_int( "P" );
@@ -68,9 +69,9 @@ testing_zgels_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -100,9 +101,9 @@ testing_zgels_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *subX, *subB;
CHAMELEON_Desc_Create(
- &descA0, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA0, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, maxMN, NRHS, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zplrnt_Tile( descB, seedB );
@@ -136,7 +137,7 @@ testing_zgels_hqr( run_arg_list_t *args, int check )
}
testing_t test_zgels_hqr;
-const char *zgels_hqr_params[] = { "nb", "ib", "trans", "m", "n", "k",
+const char *zgels_hqr_params[] = { "mtxfmt", "nb", "ib", "trans", "m", "n", "k",
"lda", "ldb", "qra", "qra", "qrp", "llvl",
"hlvl", "domino", "seedA", "seedB", NULL };
const char *zgels_hqr_output[] = { NULL };
diff --git a/testing/testing_zgemm.c b/testing/testing_zgemm.c
index c9cc3943c..17d39874d 100644
--- a/testing/testing_zgemm.c
+++ b/testing/testing_zgemm.c
@@ -28,6 +28,7 @@ testing_zgemm( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descC, *descCinit;
/* Read arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int P = parameters_getvalue_int( "P" );
cham_trans_t transA = run_arg_get_trans( args, "transA", ChamNoTrans );
@@ -72,11 +73,11 @@ testing_zgemm( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
/* Fill the matrices with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -94,7 +95,7 @@ testing_zgemm( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_zplrnt_Tile( descCinit, seedC );
hres += check_zgemm( args, transA, transB, alpha, descA, descB, beta, descCinit, descC );
@@ -110,7 +111,7 @@ testing_zgemm( run_arg_list_t *args, int check )
}
testing_t test_zgemm;
-const char *zgemm_params[] = { "nb", "transA", "transB", "m", "n", "k", "lda", "ldb",
+const char *zgemm_params[] = { "mtxfmt", "nb", "transA", "transB", "m", "n", "k", "lda", "ldb",
"ldc", "alpha", "beta", "seedA", "seedB", "seedC", NULL };
const char *zgemm_output[] = { NULL };
const char *zgemm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgeqrf.c b/testing/testing_zgeqrf.c
index 96fb92f8f..b74da21ef 100644
--- a/testing/testing_zgeqrf.c
+++ b/testing/testing_zgeqrf.c
@@ -27,15 +27,16 @@ testing_zgeqrf( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int RH = run_arg_get_int( args, "qra", 4 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int RH = run_arg_get_int( args, "qra", 4 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgeqrf( M, N );
@@ -52,7 +53,7 @@ testing_zgeqrf( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -72,7 +73,7 @@ testing_zgeqrf( run_arg_list_t *args, int check )
CHAM_desc_t *descA0 = CHAMELEON_Desc_Copy( descA, NULL );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, M, M, 0, 0, M, M, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, M, M, 0, 0, M, M, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zungqr_Tile( descA, descT, descQ );
@@ -91,7 +92,7 @@ testing_zgeqrf( run_arg_list_t *args, int check )
}
testing_t test_zgeqrf;
-const char *zgeqrf_params[] = { "nb", "ib", "m", "n", "lda", "qra", "seedA", NULL };
+const char *zgeqrf_params[] = { "mtxfmt", "nb","ib", "m", "n", "lda", "qra", "seedA", NULL };
const char *zgeqrf_output[] = { NULL };
const char *zgeqrf_outchk[] = { "||A||", "||I-QQ'||", "||A-fact(A)||", "RETURN", NULL };
diff --git a/testing/testing_zgeqrf_hqr.c b/testing/testing_zgeqrf_hqr.c
index b4d264e18..d34784a0f 100644
--- a/testing/testing_zgeqrf_hqr.c
+++ b/testing/testing_zgeqrf_hqr.c
@@ -27,19 +27,20 @@ testing_zgeqrf_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int qr_a = run_arg_get_int( args, "qra", -1 );
- int qr_p = run_arg_get_int( args, "qrp", -1 );
- int llvl = run_arg_get_int( args, "llvl", -1 );
- int hlvl = run_arg_get_int( args, "hlvl", -1 );
- int domino = run_arg_get_int( args, "domino", -1 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int qr_a = run_arg_get_int( args, "qra", -1 );
+ int qr_p = run_arg_get_int( args, "qrp", -1 );
+ int llvl = run_arg_get_int( args, "llvl", -1 );
+ int hlvl = run_arg_get_int( args, "hlvl", -1 );
+ int domino = run_arg_get_int( args, "domino", -1 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgeqrf( M, N );
@@ -51,7 +52,7 @@ testing_zgeqrf_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -80,7 +81,7 @@ testing_zgeqrf_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA0 = CHAMELEON_Desc_Copy( descA, NULL );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, M, M, 0, 0, M, M, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, M, M, 0, 0, M, M, P, Q );
CHAMELEON_zplrnt_Tile( descA0, seedA );
CHAMELEON_zungqr_param_Tile( &qrtree, descA, descTS, descTT, descQ );
@@ -101,7 +102,7 @@ testing_zgeqrf_hqr( run_arg_list_t *args, int check )
}
testing_t test_zgeqrf_hqr;
-const char *zgeqrf_hqr_params[] = { "nb", "ib", "m", "n", "lda", "qra",
+const char *zgeqrf_hqr_params[] = { "mtxfmt", "nb", "ib", "m", "n", "lda", "qra",
"qrp", "llvl", "hlvl", "domino", "seedA", NULL };
const char *zgeqrf_hqr_output[] = { NULL };
const char *zgeqrf_hqr_outchk[] = { "||A||", "||I-QQ'||", "||A-fact(A)||", "RETURN", NULL };
diff --git a/testing/testing_zgeqrs.c b/testing/testing_zgeqrs.c
index a7eb9d3c5..b77662085 100644
--- a/testing/testing_zgeqrs.c
+++ b/testing/testing_zgeqrs.c
@@ -28,18 +28,19 @@ testing_zgeqrs( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX, *descT;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", M );
- int LDB = run_arg_get_int( args, "LDB", M );
- int RH = run_arg_get_int( args, "qra", 0 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int RH = run_arg_get_int( args, "qra", 0 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgeqrs( M, N, NRHS );
@@ -63,9 +64,9 @@ testing_zgeqrs( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, M, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, M, NRHS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -108,7 +109,7 @@ testing_zgeqrs( run_arg_list_t *args, int check )
}
testing_t test_zgeqrs;
-const char *zgeqrs_params[] = { "nb", "ib", "m", "n", "k", "lda",
+const char *zgeqrs_params[] = { "mtxfmt", "nb", "ib", "m", "n", "k", "lda",
"ldb", "qra", "seedA", "seedB", NULL };
const char *zgeqrs_output[] = { NULL };
const char *zgeqrs_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgesv.c b/testing/testing_zgesv.c
index 1b38fa53d..dd87323aa 100644
--- a/testing/testing_zgesv.c
+++ b/testing/testing_zgesv.c
@@ -34,15 +34,16 @@ testing_zgesv( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgesv( N, NRHS );
@@ -50,9 +51,9 @@ testing_zgesv( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -94,7 +95,7 @@ testing_zgesv( run_arg_list_t *args, int check )
}
testing_t test_zgesv;
-const char *zgesv_params[] = { "nb", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zgesv_params[] = { "mtxfmt", "nb","n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zgesv_output[] = { NULL };
const char *zgesv_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zgetrf.c b/testing/testing_zgetrf.c
index 67bba5985..47430577f 100644
--- a/testing/testing_zgetrf.c
+++ b/testing/testing_zgetrf.c
@@ -27,13 +27,14 @@ testing_zgetrf( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgetrf( M, N );
@@ -41,7 +42,7 @@ testing_zgetrf( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -70,7 +71,7 @@ testing_zgetrf( run_arg_list_t *args, int check )
}
testing_t test_zgetrf;
-const char *zgetrf_params[] = { "nb", "m", "n", "lda", "seedA", NULL };
+const char *zgetrf_params[] = { "mtxfmt", "nb","m", "n", "lda", "seedA", NULL };
const char *zgetrf_output[] = { NULL };
const char *zgetrf_outchk[] = { "||A||", "||A-fact(A)||", "RETURN", NULL };
diff --git a/testing/testing_zgetrs.c b/testing/testing_zgetrs.c
index c665c6370..5433ea73d 100644
--- a/testing/testing_zgetrs.c
+++ b/testing/testing_zgetrs.c
@@ -28,15 +28,16 @@ testing_zgetrs( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zgetrs( N, NRHS );
@@ -44,9 +45,9 @@ testing_zgetrs( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -84,7 +85,7 @@ testing_zgetrs( run_arg_list_t *args, int check )
}
testing_t test_zgetrs;
-const char *zgetrs_params[] = { "nb", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zgetrs_params[] = { "mtxfmt", "nb","n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zgetrs_output[] = { NULL };
const char *zgetrs_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index eb0dda060..d1fdc5735 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -28,23 +28,24 @@ testing_zhemm( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descC, *descCinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( side == ChamLeft ) ? M : N ) );
- int LDB = run_arg_get_int( args, "LDB", M );
- int LDC = run_arg_get_int( args, "LDC", M );
- CHAMELEON_Complex64_t alpha = testing_zalea();
- CHAMELEON_Complex64_t beta = testing_zalea();
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int seedC = run_arg_get_int( args, "seedC", random() );
- double bump = testing_dalea();
- bump = run_arg_get_double( args, "bump", bump );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( side == ChamLeft ) ? M : N ) );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int LDC = run_arg_get_int( args, "LDC", M );
+ CHAMELEON_Complex64_t alpha = testing_zalea();
+ CHAMELEON_Complex64_t beta = testing_zalea();
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int seedC = run_arg_get_int( args, "seedC", random() );
+ double bump = testing_dalea();
+ bump = run_arg_get_double( args, "bump", bump );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zhemm( side, M, N );
@@ -63,11 +64,11 @@ testing_zhemm( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, Am, 0, 0, Am, Am, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, Am, 0, 0, Am, Am, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplghe_Tile( bump, uplo, descA, seedA );
@@ -85,7 +86,7 @@ testing_zhemm( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_zplrnt_Tile( descCinit, seedC );
hres +=
@@ -102,7 +103,7 @@ testing_zhemm( run_arg_list_t *args, int check )
}
testing_t test_zhemm;
-const char *zhemm_params[] = { "nb", "side", "uplo", "m", "n", "lda", "ldb", "ldc",
+const char *zhemm_params[] = { "mtxfmt", "nb", "side", "uplo", "m", "n", "lda", "ldb", "ldc",
"alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
const char *zhemm_output[] = { NULL };
const char *zhemm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index ca179840c..20e26c880 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -28,15 +28,16 @@ testing_zher2k( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descC, *descCinit;
/* Read arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDB = run_arg_get_int( args, "LDB", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDC = run_arg_get_int( args, "LDC", N );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDB = run_arg_get_int( args, "LDB", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDC = run_arg_get_int( args, "LDC", N );
CHAMELEON_Complex64_t alpha = testing_zalea();
double beta = testing_dalea();
int seedA = run_arg_get_int( args, "seedA", random() );
@@ -65,11 +66,11 @@ testing_zher2k( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, An, 0, 0, Am, An, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
/* Fill the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -87,7 +88,7 @@ testing_zher2k( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
CHAMELEON_zplghe_Tile( bump, uplo, descCinit, seedC );
hres +=
@@ -104,7 +105,7 @@ testing_zher2k( run_arg_list_t *args, int check )
}
testing_t test_zher2k;
-const char *zher2k_params[] = { "nb", "trans", "uplo", "n", "k", "lda", "ldb", "ldc",
+const char *zher2k_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda", "ldb", "ldc",
"alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
const char *zher2k_output[] = { NULL };
const char *zher2k_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index ff93b7ee7..28730ea71 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -29,20 +29,21 @@ testing_zherk( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descC, *descCinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDC = run_arg_get_int( args, "LDC", N );
- double alpha = testing_dalea();
- double beta = testing_dalea();
- double bump = testing_dalea();
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedC = run_arg_get_int( args, "seedC", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDC = run_arg_get_int( args, "LDC", N );
+ double alpha = testing_dalea();
+ double beta = testing_dalea();
+ double bump = testing_dalea();
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedC = run_arg_get_int( args, "seedC", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zherk( K, N );
@@ -64,9 +65,9 @@ testing_zherk( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -83,7 +84,7 @@ testing_zherk( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
CHAMELEON_zplghe_Tile( bump, uplo, descCinit, seedC );
hres +=
@@ -99,7 +100,7 @@ testing_zherk( run_arg_list_t *args, int check )
}
testing_t test_zherk;
-const char *zherk_params[] = { "nb", "trans", "uplo", "n", "k", "lda", "ldc",
+const char *zherk_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda", "ldc",
"alpha", "beta", "seedA", "seedC", "bump", NULL };
const char *zherk_output[] = { NULL };
const char *zherk_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlacpy.c b/testing/testing_zlacpy.c
index 0e068822c..6526cbf8e 100644
--- a/testing/testing_zlacpy.c
+++ b/testing/testing_zlacpy.c
@@ -58,15 +58,16 @@ testing_zlacpy( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- int LDB = run_arg_get_int( args, "LDB", M );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zlacpy( uplo, M, N );
@@ -74,9 +75,9 @@ testing_zlacpy( run_arg_list_t *args, int check )
/* Creates two different matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
/* Fills each matrix with different random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -103,7 +104,7 @@ testing_zlacpy( run_arg_list_t *args, int check )
}
testing_t test_zlacpy;
-const char *zlacpy_params[] = { "nb", "uplo", "m", "n", "lda", "ldb", "seedA", NULL };
+const char *zlacpy_params[] = { "mtxfmt", "nb","uplo", "m", "n", "lda", "ldb", "seedA", NULL };
const char *zlacpy_output[] = { NULL };
const char *zlacpy_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlange.c b/testing/testing_zlange.c
index 6484e7882..060f2741b 100644
--- a/testing/testing_zlange.c
+++ b/testing/testing_zlange.c
@@ -55,6 +55,7 @@ testing_zlange( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int P = parameters_getvalue_int( "P" );
cham_normtype_t norm_type = run_arg_get_ntype( args, "norm", ChamMaxNorm );
@@ -70,7 +71,7 @@ testing_zlange( run_arg_list_t *args, int check )
/* Creates the matrix */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -94,7 +95,7 @@ testing_zlange( run_arg_list_t *args, int check )
}
testing_t test_zlange;
-const char *zlange_params[] = { "nb", "norm", "m", "n", "lda", "seedA", NULL };
+const char *zlange_params[] = { "mtxfmt", "nb","norm", "m", "n", "lda", "seedA", NULL };
const char *zlange_output[] = { NULL };
const char *zlange_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlanhe.c b/testing/testing_zlanhe.c
index a15d6d61b..a5a8c5a94 100644
--- a/testing/testing_zlanhe.c
+++ b/testing/testing_zlanhe.c
@@ -53,6 +53,7 @@ testing_zlanhe( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int P = parameters_getvalue_int( "P" );
cham_normtype_t norm_type = run_arg_get_ntype( args, "norm", ChamMaxNorm );
@@ -71,7 +72,7 @@ testing_zlanhe( run_arg_list_t *args, int check )
/* Creates the matrix */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplghe_Tile( bump, uplo, descA, seedA );
@@ -95,7 +96,7 @@ testing_zlanhe( run_arg_list_t *args, int check )
}
testing_t test_zlanhe;
-const char *zlanhe_params[] = { "nb", "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+const char *zlanhe_params[] = { "mtxfmt", "nb","norm", "uplo", "n", "lda", "seedA", "bump", NULL };
const char *zlanhe_output[] = { NULL };
const char *zlanhe_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlansy.c b/testing/testing_zlansy.c
index fe38d04e8..90c3c4f89 100644
--- a/testing/testing_zlansy.c
+++ b/testing/testing_zlansy.c
@@ -53,6 +53,7 @@ testing_zlansy( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int P = parameters_getvalue_int( "P" );
cham_normtype_t norm_type = run_arg_get_ntype( args, "norm", ChamMaxNorm );
@@ -71,7 +72,7 @@ testing_zlansy( run_arg_list_t *args, int check )
/* Creates the matrix */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplgsy_Tile( bump, uplo, descA, seedA );
@@ -95,7 +96,7 @@ testing_zlansy( run_arg_list_t *args, int check )
}
testing_t test_zlansy;
-const char *zlansy_params[] = { "nb", "norm", "uplo", "n", "lda", "seedA", "bump", NULL };
+const char *zlansy_params[] = { "mtxfmt", "nb","norm", "uplo", "n", "lda", "seedA", "bump", NULL };
const char *zlansy_output[] = { NULL };
const char *zlansy_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlantr.c b/testing/testing_zlantr.c
index f8f11cdb2..2299d0f51 100644
--- a/testing/testing_zlantr.c
+++ b/testing/testing_zlantr.c
@@ -74,6 +74,7 @@ testing_zlantr( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int P = parameters_getvalue_int( "P" );
cham_normtype_t norm_type = run_arg_get_ntype( args, "norm", ChamMaxNorm );
@@ -91,7 +92,7 @@ testing_zlantr( run_arg_list_t *args, int check )
/* Creates the matrix */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -115,7 +116,7 @@ testing_zlantr( run_arg_list_t *args, int check )
}
testing_t test_zlantr;
-const char *zlantr_params[] = { "nb", "norm", "uplo", "diag", "m", "n", "lda", "seedA", NULL };
+const char *zlantr_params[] = { "mtxfmt", "nb","norm", "uplo", "diag", "m", "n", "lda", "seedA", NULL };
const char *zlantr_output[] = { NULL };
const char *zlantr_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlascal.c b/testing/testing_zlascal.c
index 7717d2993..708b4ed17 100644
--- a/testing/testing_zlascal.c
+++ b/testing/testing_zlascal.c
@@ -52,15 +52,16 @@ testing_zlascal( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descAinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", M );
- CHAMELEON_Complex64_t alpha = run_arg_get_complex64( args, "alpha", 1. );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ CHAMELEON_Complex64_t alpha = run_arg_get_complex64( args, "alpha", 1. );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zlascal( uplo, M, N );
@@ -68,7 +69,7 @@ testing_zlascal( run_arg_list_t *args, int check )
/* Creates the matrix */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -84,7 +85,7 @@ testing_zlascal( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descAinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descAinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_zplrnt_Tile( descAinit, seedA );
hres += check_zscale( args, uplo, alpha, descAinit, descA );
@@ -98,7 +99,7 @@ testing_zlascal( run_arg_list_t *args, int check )
}
testing_t test_zlascal;
-const char *zlascal_params[] = { "nb", "uplo", "m", "n", "lda", "alpha", "seedA", NULL };
+const char *zlascal_params[] = { "mtxfmt", "nb","uplo", "m", "n", "lda", "alpha", "seedA", NULL };
const char *zlascal_output[] = { NULL };
const char *zlascal_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zlauum.c b/testing/testing_zlauum.c
index 99b5e362c..8e8989293 100644
--- a/testing/testing_zlauum.c
+++ b/testing/testing_zlauum.c
@@ -34,13 +34,14 @@ testing_zlauum( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zlauum( N );
@@ -48,7 +49,7 @@ testing_zlauum( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Initialises the matrices with the same values */
CHAMELEON_zplghe_Tile( 0., uplo, descA, seedA );
@@ -76,7 +77,7 @@ testing_zlauum( run_arg_list_t *args, int check )
}
testing_t test_zlauum;
-const char *zlauum_params[] = { "nb", "uplo", "n", "lda", "seedA", NULL };
+const char *zlauum_params[] = { "mtxfmt", "nb","uplo", "n", "lda", "seedA", NULL };
const char *zlauum_output[] = { NULL };
const char *zlauum_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zposv.c b/testing/testing_zposv.c
index 09016d54e..a678274bd 100644
--- a/testing/testing_zposv.c
+++ b/testing/testing_zposv.c
@@ -34,16 +34,17 @@ testing_zposv( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zposv( N, NRHS );
@@ -51,9 +52,9 @@ testing_zposv( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplghe_Tile( (double)N, uplo, descA, seedA );
@@ -95,7 +96,7 @@ testing_zposv( run_arg_list_t *args, int check )
}
testing_t test_zposv;
-const char *zposv_params[] = { "nb", "uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zposv_params[] = { "mtxfmt", "nb","uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zposv_output[] = { NULL };
const char *zposv_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zpotrf.c b/testing/testing_zpotrf.c
index d3e2a452a..30da50690 100644
--- a/testing/testing_zpotrf.c
+++ b/testing/testing_zpotrf.c
@@ -27,13 +27,14 @@ testing_zpotrf( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zpotrf( N );
@@ -41,7 +42,7 @@ testing_zpotrf( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplghe_Tile( (double)N, uplo, descA, seedA );
@@ -70,7 +71,7 @@ testing_zpotrf( run_arg_list_t *args, int check )
}
testing_t test_zpotrf;
-const char *zpotrf_params[] = { "nb", "uplo", "n", "lda", "seedA", NULL };
+const char *zpotrf_params[] = { "mtxfmt", "nb","uplo", "n", "lda", "seedA", NULL };
const char *zpotrf_output[] = { NULL };
const char *zpotrf_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zpotri.c b/testing/testing_zpotri.c
index 0e57f59d3..3c144cd50 100644
--- a/testing/testing_zpotri.c
+++ b/testing/testing_zpotri.c
@@ -28,13 +28,14 @@ testing_zpotri( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zpotri( N );
@@ -42,7 +43,7 @@ testing_zpotri( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Initialise the matrix with the random values */
CHAMELEON_zplghe_Tile( (double)N, uplo, descA, seedA );
@@ -75,7 +76,7 @@ testing_zpotri( run_arg_list_t *args, int check )
}
testing_t test_zpotri;
-const char *zpotri_params[] = { "nb", "uplo", "n", "lda", "seedA", NULL };
+const char *zpotri_params[] = { "mtxfmt", "nb","uplo", "n", "lda", "seedA", NULL };
const char *zpotri_output[] = { NULL };
const char *zpotri_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zpotrs.c b/testing/testing_zpotrs.c
index 21c908a8a..8cba4c146 100644
--- a/testing/testing_zpotrs.c
+++ b/testing/testing_zpotrs.c
@@ -28,16 +28,17 @@ testing_zpotrs( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zpotrs( N, NRHS );
@@ -45,9 +46,9 @@ testing_zpotrs( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplghe_Tile( (double)N, uplo, descA, seedA );
@@ -85,7 +86,7 @@ testing_zpotrs( run_arg_list_t *args, int check )
}
testing_t test_zpotrs;
-const char *zpotrs_params[] = { "nb", "uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zpotrs_params[] = { "mtxfmt", "nb","uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zpotrs_output[] = { NULL };
const char *zpotrs_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index b6a9a2a49..5bd880499 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -28,23 +28,24 @@ testing_zsymm( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descC, *descCinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( side == ChamLeft ) ? M : N ) );
- int LDB = run_arg_get_int( args, "LDB", M );
- int LDC = run_arg_get_int( args, "LDC", M );
- CHAMELEON_Complex64_t alpha = testing_zalea();
- CHAMELEON_Complex64_t beta = testing_zalea();
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int seedC = run_arg_get_int( args, "seedC", random() );
- double bump = testing_dalea();
- bump = run_arg_get_double( args, "bump", bump );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( side == ChamLeft ) ? M : N ) );
+ int LDB = run_arg_get_int( args, "LDB", M );
+ int LDC = run_arg_get_int( args, "LDC", M );
+ CHAMELEON_Complex64_t alpha = testing_zalea();
+ CHAMELEON_Complex64_t beta = testing_zalea();
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int seedC = run_arg_get_int( args, "seedC", random() );
+ double bump = testing_dalea();
+ bump = run_arg_get_double( args, "bump", bump );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zsymm( side, M, N );
@@ -63,11 +64,11 @@ testing_zsymm( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, Am, 0, 0, Am, Am, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, Am, 0, 0, Am, Am, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplgsy_Tile( bump, uplo, descA, seedA );
@@ -85,7 +86,7 @@ testing_zsymm( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_zplrnt_Tile( descCinit, seedC );
hres +=
@@ -102,7 +103,7 @@ testing_zsymm( run_arg_list_t *args, int check )
}
testing_t test_zsymm;
-const char *zsymm_params[] = { "nb", "side", "uplo", "m", "n", "lda", "ldb", "ldc",
+const char *zsymm_params[] = { "mtxfmt", "nb", "side", "uplo", "m", "n", "lda", "ldb", "ldc",
"alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
const char *zsymm_output[] = { NULL };
const char *zsymm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 1d173f1cf..107932eeb 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -28,15 +28,16 @@ testing_zsyr2k( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descC, *descCinit;
/* Read arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDB = run_arg_get_int( args, "LDB", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDC = run_arg_get_int( args, "LDC", N );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDB = run_arg_get_int( args, "LDB", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDC = run_arg_get_int( args, "LDC", N );
CHAMELEON_Complex64_t alpha = testing_zalea();
CHAMELEON_Complex64_t beta = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
@@ -65,11 +66,11 @@ testing_zsyr2k( run_arg_list_t *args, int check )
/* Create the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, An, 0, 0, Am, An, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
/* Fill the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -87,7 +88,7 @@ testing_zsyr2k( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
CHAMELEON_zplgsy_Tile( bump, uplo, descCinit, seedC );
hres +=
@@ -104,7 +105,7 @@ testing_zsyr2k( run_arg_list_t *args, int check )
}
testing_t test_zsyr2k;
-const char *zsyr2k_params[] = { "nb", "trans", "uplo", "n", "k", "lda", "ldb", "ldc",
+const char *zsyr2k_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda", "ldb", "ldc",
"alpha", "beta", "seedA", "seedB", "seedC", "bump", NULL };
const char *zsyr2k_output[] = { NULL };
const char *zsyr2k_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 70ec507f6..31128264d 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -28,14 +28,15 @@ testing_zsyrk( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descC, *descCinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
- int LDC = run_arg_get_int( args, "LDC", N );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? N : K ) );
+ int LDC = run_arg_get_int( args, "LDC", N );
CHAMELEON_Complex64_t alpha = testing_zalea();
CHAMELEON_Complex64_t beta = testing_zalea();
CHAMELEON_Complex64_t bump = testing_zalea();
@@ -63,9 +64,9 @@ testing_zsyrk( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -82,7 +83,7 @@ testing_zsyrk( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descCinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
+ &descCinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, N, N, P, Q );
CHAMELEON_zplgsy_Tile( bump, uplo, descCinit, seedC );
hres +=
@@ -98,7 +99,7 @@ testing_zsyrk( run_arg_list_t *args, int check )
}
testing_t test_zsyrk;
-const char *zsyrk_params[] = { "nb", "trans", "uplo", "n", "k", "lda", "ldc",
+const char *zsyrk_params[] = { "mtxfmt", "nb", "trans", "uplo", "n", "k", "lda", "ldc",
"alpha", "beta", "seedA", "seedC", "bump", NULL };
const char *zsyrk_output[] = { NULL };
const char *zsyrk_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsysv.c b/testing/testing_zsysv.c
index 0b5022a80..4388dd1fd 100644
--- a/testing/testing_zsysv.c
+++ b/testing/testing_zsysv.c
@@ -34,16 +34,17 @@ testing_zsysv( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zsysv( N, NRHS );
@@ -51,9 +52,9 @@ testing_zsysv( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplgsy_Tile( (double)N, uplo, descA, seedA );
@@ -95,7 +96,7 @@ testing_zsysv( run_arg_list_t *args, int check )
}
testing_t test_zsysv;
-const char *zsysv_params[] = { "nb", "uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zsysv_params[] = { "mtxfmt", "nb","uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zsysv_output[] = { NULL };
const char *zsysv_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsytrf.c b/testing/testing_zsytrf.c
index d47c98a66..2ec913eb8 100644
--- a/testing/testing_zsytrf.c
+++ b/testing/testing_zsytrf.c
@@ -27,13 +27,14 @@ testing_zsytrf( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zpotrf( N );
@@ -41,7 +42,7 @@ testing_zsytrf( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplgsy_Tile( (double)N, uplo, descA, seedA );
@@ -70,7 +71,7 @@ testing_zsytrf( run_arg_list_t *args, int check )
}
testing_t test_zsytrf;
-const char *zsytrf_params[] = { "nb", "uplo", "n", "lda", "seedA", NULL };
+const char *zsytrf_params[] = { "mtxfmt", "nb","uplo", "n", "lda", "seedA", NULL };
const char *zsytrf_output[] = { NULL };
const char *zsytrf_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zsytrs.c b/testing/testing_zsytrs.c
index 4c7c9c8a3..5a026592b 100644
--- a/testing/testing_zsytrs.c
+++ b/testing/testing_zsytrs.c
@@ -28,16 +28,17 @@ testing_zsytrs( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descX;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int NRHS = run_arg_get_int( args, "NRHS", 1 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int NRHS = run_arg_get_int( args, "NRHS", 1 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = 0; // flops_zsytrs( N, NRHS );
@@ -45,9 +46,9 @@ testing_zsytrs( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descX, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
+ &descX, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, NRHS, 0, 0, N, NRHS, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplgsy_Tile( (double)N, uplo, descA, seedA );
@@ -85,7 +86,7 @@ testing_zsytrs( run_arg_list_t *args, int check )
}
testing_t test_zsytrs;
-const char *zsytrs_params[] = { "nb", "uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
+const char *zsytrs_params[] = { "mtxfmt", "nb","uplo", "n", "nrhs", "lda", "ldb", "seedA", "seedB", NULL };
const char *zsytrs_output[] = { NULL };
const char *zsytrs_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_ztradd.c b/testing/testing_ztradd.c
index 1dc329ad3..0e1759632 100644
--- a/testing/testing_ztradd.c
+++ b/testing/testing_ztradd.c
@@ -55,14 +55,15 @@ testing_ztradd( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? M : N ) );
- int LDB = run_arg_get_int( args, "LDB", M );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int LDA = run_arg_get_int( args, "LDA", ( ( trans == ChamNoTrans ) ? M : N ) );
+ int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
CHAMELEON_Complex64_t beta = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
@@ -87,9 +88,9 @@ testing_ztradd( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, Am, An, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
switch ( uplo ) {
@@ -141,7 +142,7 @@ testing_ztradd( run_arg_list_t *args, int check )
}
testing_t test_ztradd;
-const char *ztradd_params[] = { "nb", "trans", "uplo", "m", "n", "lda",
+const char *ztradd_params[] = { "mtxfmt", "nb", "trans", "uplo", "m", "n", "lda",
"ldb", "alpha", "beta", "seedA", "seedB", NULL };
const char *ztradd_output[] = { NULL };
const char *ztradd_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index 12caaffeb..7d7b1041c 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -28,20 +28,21 @@ testing_ztrmm( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descBinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
- int N = run_arg_get_int( args, "N", 1000 );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", N );
- int LDB = run_arg_get_int( args, "LDB", N );
- CHAMELEON_Complex64_t alpha = testing_zalea();
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ CHAMELEON_Complex64_t alpha = testing_zalea();
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_ztrmm( side, N, K );
@@ -61,9 +62,9 @@ testing_ztrmm( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
/* Fills the matrix with random values */
CHAMELEON_zplrnt_Tile( descA, seedA );
@@ -80,7 +81,7 @@ testing_ztrmm( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Desc_Create(
- &descBinit, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
+ &descBinit, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, Bn, 0, 0, Bm, Bn, P, Q );
CHAMELEON_zplrnt_Tile( descBinit, seedB );
hres += check_ztrmm( args, CHECK_TRMM, side, uplo, trans, diag, alpha, descA, descB, descBinit );
@@ -95,7 +96,7 @@ testing_ztrmm( run_arg_list_t *args, int check )
}
testing_t test_ztrmm;
-const char *ztrmm_params[] = { "nb", "trans", "side", "uplo", "diag", "n", "k",
+const char *ztrmm_params[] = { "mtxfmt", "nb", "trans", "side", "uplo", "diag", "n", "k",
"lda", "ldb", "alpha", "seedA", "seedB", NULL };
const char *ztrmm_output[] = { NULL };
const char *ztrmm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 1fc4273e9..46fa36846 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -27,21 +27,22 @@ testing_ztrsm( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descB, *descBinit;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- cham_side_t side = run_arg_get_side( args, "side", ChamLeft );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int Ak = ( side == ChamLeft ) ? M : N;
- int LDA = run_arg_get_int( args, "LDA", Ak );
- int LDB = run_arg_get_int( args, "LDB", N );
- CHAMELEON_Complex64_t alpha = testing_zalea();
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedB = run_arg_get_int( args, "seedB", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ cham_side_t side = run_arg_get_side( args, "side", ChamLeft );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int Ak = ( side == ChamLeft ) ? M : N;
+ int LDA = run_arg_get_int( args, "LDA", Ak );
+ int LDB = run_arg_get_int( args, "LDB", N );
+ CHAMELEON_Complex64_t alpha = testing_zalea();
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedB = run_arg_get_int( args, "seedB", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_ztrsm( side, M, N );
@@ -51,9 +52,9 @@ testing_ztrsm( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, Ak, 0, 0, Ak, Ak, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
CHAMELEON_Desc_Create(
- &descB, NULL, ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
+ &descB, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDB, N, 0, 0, M, N, P, Q );
/* Fills the matrix with random values */
/* We bump a little bit the diagonal to make it stable */
@@ -86,7 +87,7 @@ testing_ztrsm( run_arg_list_t *args, int check )
}
testing_t test_ztrsm;
-const char *ztrsm_params[] = { "nb", "side", "uplo", "trans", "diag", "m", "n",
+const char *ztrsm_params[] = { "mtxfmt", "nb", "side", "uplo", "trans", "diag", "m", "n",
"lda", "ldb", "alpha", "seedA", "seedB", NULL };
const char *ztrsm_output[] = { NULL };
const char *ztrsm_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_ztrtri.c b/testing/testing_ztrtri.c
index 49854a9e3..9901ceb7b 100644
--- a/testing/testing_ztrtri.c
+++ b/testing/testing_ztrtri.c
@@ -27,14 +27,15 @@ testing_ztrtri( run_arg_list_t *args, int check )
CHAM_desc_t *descA;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int P = parameters_getvalue_int( "P" );
- cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
- cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
- int N = run_arg_get_int( args, "N", 1000 );
- int LDA = run_arg_get_int( args, "LDA", N );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int P = parameters_getvalue_int( "P" );
+ cham_uplo_t uplo = run_arg_get_uplo( args, "uplo", ChamUpper );
+ cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int LDA = run_arg_get_int( args, "LDA", N );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_ztrtri( N );
@@ -42,7 +43,7 @@ testing_ztrtri( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
/* Initialises the matrices with the same values */
CHAMELEON_zplghe_Tile( (double)N, uplo, descA, seedA );
@@ -71,7 +72,7 @@ testing_ztrtri( run_arg_list_t *args, int check )
}
testing_t test_ztrtri;
-const char *ztrtri_params[] = { "nb", "uplo", "diag", "n", "lda", "seedA", NULL };
+const char *ztrtri_params[] = { "mtxfmt", "nb","uplo", "diag", "n", "lda", "seedA", NULL };
const char *ztrtri_output[] = { NULL };
const char *ztrtri_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zunglq.c b/testing/testing_zunglq.c
index 22864c2cc..12cd3b998 100644
--- a/testing/testing_zunglq.c
+++ b/testing/testing_zunglq.c
@@ -27,16 +27,17 @@ testing_zunglq( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT, *descQ;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
- int LDA = run_arg_get_int( args, "LDA", M );
- int RH = run_arg_get_int( args, "qra", 0 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int RH = run_arg_get_int( args, "qra", 0 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zunglq( M, N, K );
@@ -60,9 +61,9 @@ testing_zunglq( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, K, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, K, N, P, Q );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -90,7 +91,7 @@ testing_zunglq( run_arg_list_t *args, int check )
}
testing_t test_zunglq;
-const char *zunglq_params[] = { "nb", "ib", "m", "n", "k", "lda", "qra", "seedA", NULL };
+const char *zunglq_params[] = { "mtxfmt", "nb","ib", "m", "n", "k", "lda", "qra", "seedA", NULL };
const char *zunglq_output[] = { NULL };
const char *zunglq_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zunglq_hqr.c b/testing/testing_zunglq_hqr.c
index 6b5527ef5..3c55d96a3 100644
--- a/testing/testing_zunglq_hqr.c
+++ b/testing/testing_zunglq_hqr.c
@@ -27,20 +27,21 @@ testing_zunglq_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT, *descQ;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
- int LDA = run_arg_get_int( args, "LDA", M );
- int qr_a = run_arg_get_int( args, "qra", -1 );
- int qr_p = run_arg_get_int( args, "qrp", -1 );
- int llvl = run_arg_get_int( args, "llvl", -1 );
- int hlvl = run_arg_get_int( args, "hlvl", -1 );
- int domino = run_arg_get_int( args, "domino", -1 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int qr_a = run_arg_get_int( args, "qra", -1 );
+ int qr_p = run_arg_get_int( args, "qrp", -1 );
+ int llvl = run_arg_get_int( args, "llvl", -1 );
+ int hlvl = run_arg_get_int( args, "hlvl", -1 );
+ int domino = run_arg_get_int( args, "domino", -1 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zunglq( M, N, K );
@@ -59,9 +60,9 @@ testing_zunglq_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, K, N, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, K, N, P, Q );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descTT, P, Q );
@@ -100,7 +101,7 @@ testing_zunglq_hqr( run_arg_list_t *args, int check )
}
testing_t test_zunglq_hqr;
-const char *zunglq_hqr_params[] = { "nb", "ib", "m", "n", "k", "lda", "qra",
+const char *zunglq_hqr_params[] = { "mtxfmt", "nb", "ib", "m", "n", "k", "lda", "qra",
"qrp", "llvl", "hlvl", "domino", "seedA", NULL };
const char *zunglq_hqr_output[] = { NULL };
const char *zunglq_hqr_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zungqr.c b/testing/testing_zungqr.c
index 05e38cd56..3497672ed 100644
--- a/testing/testing_zungqr.c
+++ b/testing/testing_zungqr.c
@@ -27,16 +27,17 @@ testing_zungqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT, *descQ;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
- int LDA = run_arg_get_int( args, "LDA", M );
- int RH = run_arg_get_int( args, "qra", 0 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int RH = run_arg_get_int( args, "qra", 0 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zungqr( M, N, K );
@@ -60,9 +61,9 @@ testing_zungqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, M, K, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, M, K, P, Q );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descT, P, Q );
/* Fills the matrix with random values */
@@ -90,7 +91,7 @@ testing_zungqr( run_arg_list_t *args, int check )
}
testing_t test_zungqr;
-const char *zungqr_params[] = { "nb", "ib", "m", "n", "k", "lda", "qra", "seedA", NULL };
+const char *zungqr_params[] = { "mtxfmt", "nb","ib", "m", "n", "k", "lda", "qra", "seedA", NULL };
const char *zungqr_output[] = { NULL };
const char *zungqr_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zungqr_hqr.c b/testing/testing_zungqr_hqr.c
index 850a5a451..04831decf 100644
--- a/testing/testing_zungqr_hqr.c
+++ b/testing/testing_zungqr_hqr.c
@@ -27,20 +27,21 @@ testing_zungqr_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT, *descQ;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
- int LDA = run_arg_get_int( args, "LDA", M );
- int qr_a = run_arg_get_int( args, "qra", -1 );
- int qr_p = run_arg_get_int( args, "qrp", -1 );
- int llvl = run_arg_get_int( args, "llvl", -1 );
- int hlvl = run_arg_get_int( args, "hlvl", -1 );
- int domino = run_arg_get_int( args, "domino", -1 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
+ int LDA = run_arg_get_int( args, "LDA", M );
+ int qr_a = run_arg_get_int( args, "qra", -1 );
+ int qr_p = run_arg_get_int( args, "qrp", -1 );
+ int llvl = run_arg_get_int( args, "llvl", -1 );
+ int hlvl = run_arg_get_int( args, "hlvl", -1 );
+ int domino = run_arg_get_int( args, "domino", -1 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zungqr( M, N, K );
@@ -59,9 +60,9 @@ testing_zungqr_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, M, K, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, M, K, P, Q );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descTT, P, Q );
@@ -100,7 +101,7 @@ testing_zungqr_hqr( run_arg_list_t *args, int check )
}
testing_t test_zungqr_hqr;
-const char *zungqr_hqr_params[] = { "nb", "ib", "m", "n", "k", "lda", "qra",
+const char *zungqr_hqr_params[] = { "mtxfmt", "nb", "ib", "m", "n", "k", "lda", "qra",
"qrp", "llvl", "hlvl", "domino", "seedA", NULL };
const char *zungqr_hqr_output[] = { NULL };
const char *zungqr_hqr_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zunmlq.c b/testing/testing_zunmlq.c
index cd17d466f..41ccb3abb 100644
--- a/testing/testing_zunmlq.c
+++ b/testing/testing_zunmlq.c
@@ -29,20 +29,21 @@ testing_zunmlq( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT, *descC;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", N );
- int LDA = run_arg_get_int( args, "LDA", K );
- int LDC = run_arg_get_int( args, "LDC", M );
- int RH = run_arg_get_int( args, "qra", 4 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedC = run_arg_get_int( args, "seedC", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", N );
+ int LDA = run_arg_get_int( args, "LDA", K );
+ int LDC = run_arg_get_int( args, "LDC", M );
+ int RH = run_arg_get_int( args, "qra", 4 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedC = run_arg_get_int( args, "seedC", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zunmlq( side, M, N, K );
@@ -62,9 +63,9 @@ testing_zunmlq( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, K, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, K, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descT, P, Q );
/* Fills the matrix with random values */
@@ -91,7 +92,7 @@ testing_zunmlq( run_arg_list_t *args, int check )
CHAMELEON_zplrnt_Tile( descC0, seedC );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, An, An, 0, 0, An, An, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, An, An, 0, 0, An, An, P, Q );
CHAMELEON_zunglq_Tile( descA, descT, descQ );
hres += check_zqc( args, side, trans, descC0, descQ, descC );
@@ -108,7 +109,7 @@ testing_zunmlq( run_arg_list_t *args, int check )
}
testing_t test_zunmlq;
-const char *zunmlq_params[] = { "nb", "ib", "side", "trans", "m", "n", "k",
+const char *zunmlq_params[] = { "mtxfmt", "nb", "ib", "side", "trans", "m", "n", "k",
"lda", "ldc", "qra", "seedA", "seedC", NULL };
const char *zunmlq_output[] = { NULL };
const char *zunmlq_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zunmlq_hqr.c b/testing/testing_zunmlq_hqr.c
index a00808d90..cc500bfa1 100644
--- a/testing/testing_zunmlq_hqr.c
+++ b/testing/testing_zunmlq_hqr.c
@@ -29,6 +29,7 @@ testing_zunmlq_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT, *descC;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int ib = run_arg_get_int( args, "ib", 48 );
int P = parameters_getvalue_int( "P" );
@@ -61,9 +62,9 @@ testing_zunmlq_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, K, An, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, An, 0, 0, K, An, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descTT, P, Q );
@@ -99,7 +100,7 @@ testing_zunmlq_hqr( run_arg_list_t *args, int check )
CHAMELEON_zplrnt_Tile( descC0, seedC );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, An, An, 0, 0, An, An, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, An, An, 0, 0, An, An, P, Q );
CHAMELEON_zunglq_param_Tile( &qrtree, descA, descTS, descTT, descQ );
hres += check_zqc( args, side, trans, descC0, descQ, descC );
@@ -118,7 +119,7 @@ testing_zunmlq_hqr( run_arg_list_t *args, int check )
}
testing_t test_zunmlq_hqr;
-const char *zunmlq_hqr_params[] = { "nb", "ib", "side", "trans", "m", "n",
+const char *zunmlq_hqr_params[] = { "mtxfmt", "nb", "ib", "side", "trans", "m", "n",
"k", "lda", "ldc", "qra", "qrp", "llvl",
"hlvl", "domino", "seedA", "seedC", NULL };
const char *zunmlq_hqr_output[] = { NULL };
diff --git a/testing/testing_zunmqr.c b/testing/testing_zunmqr.c
index e34113f60..e2c3717cd 100644
--- a/testing/testing_zunmqr.c
+++ b/testing/testing_zunmqr.c
@@ -29,20 +29,21 @@ testing_zunmqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descT, *descC;
/* Reads arguments */
- int nb = run_arg_get_int( args, "nb", 320 );
- int ib = run_arg_get_int( args, "ib", 48 );
- int P = parameters_getvalue_int( "P" );
- cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
- cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
- int N = run_arg_get_int( args, "N", 1000 );
- int M = run_arg_get_int( args, "M", N );
- int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
- int LDA = run_arg_get_int( args, "LDA", ( side == ChamLeft ) ? M : N );
- int LDC = run_arg_get_int( args, "LDC", M );
- int RH = run_arg_get_int( args, "qra", 4 );
- int seedA = run_arg_get_int( args, "seedA", random() );
- int seedC = run_arg_get_int( args, "seedC", random() );
- int Q = parameters_compute_q( P );
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
+ int nb = run_arg_get_int( args, "nb", 320 );
+ int ib = run_arg_get_int( args, "ib", 48 );
+ int P = parameters_getvalue_int( "P" );
+ cham_side_t side = run_arg_get_uplo( args, "side", ChamLeft );
+ cham_trans_t trans = run_arg_get_trans( args, "trans", ChamNoTrans );
+ int N = run_arg_get_int( args, "N", 1000 );
+ int M = run_arg_get_int( args, "M", N );
+ int K = run_arg_get_int( args, "K", chameleon_min( M, N ) );
+ int LDA = run_arg_get_int( args, "LDA", ( side == ChamLeft ) ? M : N );
+ int LDC = run_arg_get_int( args, "LDC", M );
+ int RH = run_arg_get_int( args, "qra", 4 );
+ int seedA = run_arg_get_int( args, "seedA", random() );
+ int seedC = run_arg_get_int( args, "seedC", random() );
+ int Q = parameters_compute_q( P );
cham_fixdbl_t t, gflops;
cham_fixdbl_t flops = flops_zunmqr( side, M, N, K );
@@ -62,9 +63,9 @@ testing_zunmqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, Am, K, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, Am, K, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descT, P, Q );
/* Fills the matrix with random values */
@@ -91,7 +92,7 @@ testing_zunmqr( run_arg_list_t *args, int check )
CHAMELEON_zplrnt_Tile( descC0, seedC );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, Am, Am, 0, 0, Am, Am, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, Am, Am, 0, 0, Am, Am, P, Q );
CHAMELEON_zungqr_Tile( descA, descT, descQ );
hres += check_zqc( args, side, trans, descC0, descQ, descC );
@@ -108,7 +109,7 @@ testing_zunmqr( run_arg_list_t *args, int check )
}
testing_t test_zunmqr;
-const char *zunmqr_params[] = { "nb", "ib", "side", "trans", "m", "n", "k",
+const char *zunmqr_params[] = { "mtxfmt", "nb", "ib", "side", "trans", "m", "n", "k",
"lda", "ldc", "qra", "seedA", "seedC", NULL };
const char *zunmqr_output[] = { NULL };
const char *zunmqr_outchk[] = { "RETURN", NULL };
diff --git a/testing/testing_zunmqr_hqr.c b/testing/testing_zunmqr_hqr.c
index 0fd785b41..f44306a94 100644
--- a/testing/testing_zunmqr_hqr.c
+++ b/testing/testing_zunmqr_hqr.c
@@ -29,6 +29,7 @@ testing_zunmqr_hqr( run_arg_list_t *args, int check )
CHAM_desc_t *descA, *descTS, *descTT, *descC;
/* Reads arguments */
+ intptr_t mtxfmt = parameters_getvalue_int( "mtxfmt" );
int nb = run_arg_get_int( args, "nb", 320 );
int ib = run_arg_get_int( args, "ib", 48 );
int P = parameters_getvalue_int( "P" );
@@ -61,9 +62,9 @@ testing_zunmqr_hqr( run_arg_list_t *args, int check )
/* Creates the matrices */
CHAMELEON_Desc_Create(
- &descA, NULL, ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, Am, K, P, Q );
+ &descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, K, 0, 0, Am, K, P, Q );
CHAMELEON_Desc_Create(
- &descC, NULL, ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
+ &descC, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDC, N, 0, 0, M, N, P, Q );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descTT, P, Q );
@@ -99,7 +100,7 @@ testing_zunmqr_hqr( run_arg_list_t *args, int check )
CHAMELEON_zplrnt_Tile( descC0, seedC );
CHAMELEON_Desc_Create(
- &descQ, NULL, ChamComplexDouble, nb, nb, nb * nb, Am, Am, 0, 0, Am, Am, P, Q );
+ &descQ, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, Am, Am, 0, 0, Am, Am, P, Q );
CHAMELEON_zungqr_param_Tile( &qrtree, descA, descTS, descTT, descQ );
hres += check_zqc( args, side, trans, descC0, descQ, descC );
@@ -118,7 +119,7 @@ testing_zunmqr_hqr( run_arg_list_t *args, int check )
}
testing_t test_zunmqr_hqr;
-const char *zunmqr_hqr_params[] = { "nb", "ib", "side", "trans", "m", "n",
+const char *zunmqr_hqr_params[] = { "mtxfmt", "nb", "ib", "side", "trans", "m", "n",
"k", "lda", "ldc", "qra", "qrp", "llvl",
"hlvl", "domino", "seedA", "seedC", NULL };
const char *zunmqr_hqr_output[] = { NULL };
--
GitLab