From 700a5549acc875aa42c6cc0eca169e238919d78e 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 ec0e40e79..cd8f322e1 100644 --- a/testing/testing_zgeadd.c +++ b/testing/testing_zgeadd.c @@ -43,16 +43,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; @@ -74,9 +75,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 ); @@ -108,7 +109,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 8c73a2489..46c807693 100644 --- a/testing/testing_zgelqf.c +++ b/testing/testing_zgelqf.c @@ -28,15 +28,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 ); @@ -53,7 +54,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 */ @@ -73,7 +74,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 ); @@ -93,7 +94,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 14e115298..eb0c7ffd1 100644 --- a/testing/testing_zgelqf_hqr.c +++ b/testing/testing_zgelqf_hqr.c @@ -28,19 +28,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 ); @@ -52,7 +53,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 ); @@ -81,7 +82,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 ); @@ -103,7 +104,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 10777ed62..f1c63eb54 100644 --- a/testing/testing_zgelqs.c +++ b/testing/testing_zgelqs.c @@ -36,18 +36,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(); @@ -71,9 +72,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 */ @@ -110,7 +111,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 222478fab..48882a23e 100644 --- a/testing/testing_zgels.c +++ b/testing/testing_zgels.c @@ -36,20 +36,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 ); @@ -69,9 +70,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 */ @@ -91,9 +92,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 ); @@ -126,7 +127,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 03b043234..6b3395e07 100644 --- a/testing/testing_zgels_hqr.c +++ b/testing/testing_zgels_hqr.c @@ -36,6 +36,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" ); @@ -65,9 +66,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 ); @@ -97,9 +98,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 ); @@ -134,7 +135,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 06f825df8..faa622c7f 100644 --- a/testing/testing_zgemm.c +++ b/testing/testing_zgemm.c @@ -29,6 +29,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 ); @@ -73,11 +74,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 ); @@ -95,7 +96,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 ); @@ -112,7 +113,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 321de3169..1d0333976 100644 --- a/testing/testing_zgeqrf.c +++ b/testing/testing_zgeqrf.c @@ -28,15 +28,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 ); @@ -53,7 +54,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 */ @@ -73,7 +74,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 ); @@ -93,7 +94,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 77c60a42b..f88085162 100644 --- a/testing/testing_zgeqrf_hqr.c +++ b/testing/testing_zgeqrf_hqr.c @@ -28,19 +28,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 ); @@ -52,7 +53,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 ); @@ -81,7 +82,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 ); @@ -103,7 +104,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 c107f7bb6..e31d614da 100644 --- a/testing/testing_zgeqrs.c +++ b/testing/testing_zgeqrs.c @@ -29,18 +29,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 ); @@ -64,9 +65,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 */ @@ -110,7 +111,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 529c7e0f8..2fd79e290 100644 --- a/testing/testing_zgesv.c +++ b/testing/testing_zgesv.c @@ -35,15 +35,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 ); @@ -51,9 +52,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 ); @@ -96,7 +97,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 f71c404d4..db57f044c 100644 --- a/testing/testing_zgetrf.c +++ b/testing/testing_zgetrf.c @@ -28,13 +28,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 ); @@ -42,7 +43,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 ); @@ -72,7 +73,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 9b864944a..e3ea3f6e6 100644 --- a/testing/testing_zgetrs.c +++ b/testing/testing_zgetrs.c @@ -29,15 +29,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 ); @@ -45,9 +46,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 ); @@ -86,7 +87,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 90269d452..4ba581da8 100644 --- a/testing/testing_zhemm.c +++ b/testing/testing_zhemm.c @@ -29,23 +29,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 ); @@ -64,11 +65,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 ); @@ -86,7 +87,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 += @@ -104,7 +105,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 0c2214be9..e842a2390 100644 --- a/testing/testing_zher2k.c +++ b/testing/testing_zher2k.c @@ -29,15 +29,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() ); @@ -66,11 +67,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 ); @@ -88,7 +89,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 += @@ -106,7 +107,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 99fbe8e1c..1cbf484d0 100644 --- a/testing/testing_zherk.c +++ b/testing/testing_zherk.c @@ -30,20 +30,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 ); @@ -65,9 +66,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 ); @@ -84,7 +85,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 += @@ -101,7 +102,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 3b07824fc..69148e156 100644 --- a/testing/testing_zlacpy.c +++ b/testing/testing_zlacpy.c @@ -59,15 +59,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 ); @@ -75,9 +76,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 ); @@ -105,7 +106,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 cbe523d37..3b6c14569 100644 --- a/testing/testing_zlange.c +++ b/testing/testing_zlange.c @@ -56,6 +56,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 ); @@ -71,7 +72,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 ); @@ -96,7 +97,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 14a313447..1cf137780 100644 --- a/testing/testing_zlanhe.c +++ b/testing/testing_zlanhe.c @@ -54,6 +54,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 ); @@ -72,7 +73,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 ); @@ -97,7 +98,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 881e55901..235757769 100644 --- a/testing/testing_zlansy.c +++ b/testing/testing_zlansy.c @@ -54,6 +54,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 ); @@ -72,7 +73,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 ); @@ -97,7 +98,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 3a764911b..d91c00c3c 100644 --- a/testing/testing_zlantr.c +++ b/testing/testing_zlantr.c @@ -55,6 +55,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 ); @@ -72,7 +73,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 ); @@ -97,7 +98,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 e0da00963..86d40d2a5 100644 --- a/testing/testing_zlascal.c +++ b/testing/testing_zlascal.c @@ -53,15 +53,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 ); @@ -69,7 +70,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 ); @@ -85,7 +86,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 ); @@ -100,7 +101,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 82311bf7b..693ea0690 100644 --- a/testing/testing_zlauum.c +++ b/testing/testing_zlauum.c @@ -35,13 +35,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 ); @@ -49,7 +50,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 ); @@ -78,7 +79,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 8d26d7b21..e999878b6 100644 --- a/testing/testing_zposv.c +++ b/testing/testing_zposv.c @@ -35,16 +35,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 ); @@ -52,9 +53,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 ); @@ -97,7 +98,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 eb24d9517..503a16c46 100644 --- a/testing/testing_zpotrf.c +++ b/testing/testing_zpotrf.c @@ -28,13 +28,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 ); @@ -42,7 +43,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 ); @@ -72,7 +73,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 85a2d1fe9..9bcbc66b0 100644 --- a/testing/testing_zpotri.c +++ b/testing/testing_zpotri.c @@ -29,13 +29,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 ); @@ -43,7 +44,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 ); @@ -77,7 +78,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 cd55d5742..7d049e919 100644 --- a/testing/testing_zpotrs.c +++ b/testing/testing_zpotrs.c @@ -29,16 +29,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 ); @@ -46,9 +47,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 ); @@ -87,7 +88,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 930f60e54..2a4c9b7d4 100644 --- a/testing/testing_zsymm.c +++ b/testing/testing_zsymm.c @@ -29,23 +29,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 ); @@ -64,11 +65,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 ); @@ -86,7 +87,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 += @@ -104,7 +105,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 afaf02240..98179933c 100644 --- a/testing/testing_zsyr2k.c +++ b/testing/testing_zsyr2k.c @@ -29,15 +29,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() ); @@ -66,11 +67,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 ); @@ -88,7 +89,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 += @@ -106,7 +107,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 39b41042d..c5ea16773 100644 --- a/testing/testing_zsyrk.c +++ b/testing/testing_zsyrk.c @@ -29,14 +29,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(); @@ -64,9 +65,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 ); @@ -83,7 +84,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 += @@ -100,7 +101,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 4f924d94b..338ea6d03 100644 --- a/testing/testing_zsysv.c +++ b/testing/testing_zsysv.c @@ -35,16 +35,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 ); @@ -52,9 +53,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 ); @@ -97,7 +98,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 c5a0fce83..bdf48d5c5 100644 --- a/testing/testing_zsytrf.c +++ b/testing/testing_zsytrf.c @@ -28,13 +28,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 ); @@ -42,7 +43,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 ); @@ -72,7 +73,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 a3d1d628c..387ac2d07 100644 --- a/testing/testing_zsytrs.c +++ b/testing/testing_zsytrs.c @@ -29,16 +29,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 ); @@ -46,9 +47,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 ); @@ -87,7 +88,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 4aa6edfc5..b3f6dd152 100644 --- a/testing/testing_ztradd.c +++ b/testing/testing_ztradd.c @@ -56,14 +56,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() ); @@ -88,9 +89,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 ) { @@ -143,7 +144,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 b8fe36443..9750bf007 100644 --- a/testing/testing_ztrmm.c +++ b/testing/testing_ztrmm.c @@ -29,20 +29,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 ); @@ -62,9 +63,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 ); @@ -81,7 +82,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 ); @@ -97,7 +98,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 bca5b7bd8..8ada65440 100644 --- a/testing/testing_ztrsm.c +++ b/testing/testing_ztrsm.c @@ -29,20 +29,21 @@ 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_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_ztrsm( side, N, K ); @@ -62,9 +63,9 @@ testing_ztrsm( 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 */ /* We bump a little bit the diagonal to make it stable */ @@ -82,7 +83,7 @@ testing_ztrsm( 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_TRSM, side, uplo, trans, diag, alpha, descA, descB, descBinit ); @@ -98,7 +99,7 @@ testing_ztrsm( run_arg_list_t *args, int check ) } testing_t test_ztrsm; -const char *ztrsm_params[] = { "nb", "trans", "side", "uplo", "diag", "n", "k", +const char *ztrsm_params[] = { "mtxfmt", "nb", "trans", "side", "uplo", "diag", "n", "k", "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 549f33f61..fe34b973e 100644 --- a/testing/testing_ztrtri.c +++ b/testing/testing_ztrtri.c @@ -28,14 +28,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 ); @@ -43,7 +44,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 ); @@ -73,7 +74,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 153fb9a95..873e52105 100644 --- a/testing/testing_zunglq.c +++ b/testing/testing_zunglq.c @@ -28,16 +28,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 ); @@ -61,9 +62,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 */ @@ -92,7 +93,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 d0349fbd2..6d45c7f25 100644 --- a/testing/testing_zunglq_hqr.c +++ b/testing/testing_zunglq_hqr.c @@ -28,20 +28,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 ); @@ -60,9 +61,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 ); @@ -102,7 +103,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 934fa05d5..e8b22f138 100644 --- a/testing/testing_zungqr.c +++ b/testing/testing_zungqr.c @@ -28,16 +28,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 ); @@ -61,9 +62,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 */ @@ -92,7 +93,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 364a3cf63..caf0af672 100644 --- a/testing/testing_zungqr_hqr.c +++ b/testing/testing_zungqr_hqr.c @@ -28,20 +28,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 ); @@ -60,9 +61,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 ); @@ -102,7 +103,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 dd6db201e..7b547ee04 100644 --- a/testing/testing_zunmlq.c +++ b/testing/testing_zunmlq.c @@ -30,20 +30,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 ); @@ -63,9 +64,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 */ @@ -92,7 +93,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 ); @@ -110,7 +111,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 eb683f73e..1af35ad76 100644 --- a/testing/testing_zunmlq_hqr.c +++ b/testing/testing_zunmlq_hqr.c @@ -30,6 +30,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" ); @@ -62,9 +63,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 ); @@ -100,7 +101,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 ); @@ -120,7 +121,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 7059dbb7e..0331d1f46 100644 --- a/testing/testing_zunmqr.c +++ b/testing/testing_zunmqr.c @@ -30,20 +30,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 ); @@ -63,9 +64,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 */ @@ -92,7 +93,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 ); @@ -110,7 +111,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 10a204f4c..d78ac6770 100644 --- a/testing/testing_zunmqr_hqr.c +++ b/testing/testing_zunmqr_hqr.c @@ -30,6 +30,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" ); @@ -62,9 +63,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 ); @@ -100,7 +101,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 ); @@ -120,7 +121,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