From 05ee17eb41446866a072d24afe5c86ba4e7fc8bb Mon Sep 17 00:00:00 2001
From: Alycia Lisito <alycia.lisito@inria.fr>
Date: Thu, 17 Feb 2022 08:50:17 +0100
Subject: [PATCH] testing: Fix mistakes in the standard testings
---
testing/testing_zhemm.c | 13 ++++---------
testing/testing_zher2k.c | 14 +++++++++-----
testing/testing_zherk.c | 6 +++---
testing/testing_zposv.c | 4 ++--
testing/testing_zpotrs.c | 2 +-
testing/testing_zsymm.c | 19 +++++++------------
testing/testing_zsyr2k.c | 16 ++++++++++------
testing/testing_zsyrk.c | 2 +-
testing/testing_ztrmm.c | 26 ++++++++------------------
testing/testing_ztrsm.c | 8 ++++----
10 files changed, 49 insertions(+), 61 deletions(-)
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index b89b2bb3c..3fd659ffb 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -137,7 +137,7 @@ testing_zhemm_std( run_arg_list_t *args, int check )
double bump = testing_dalea();
/* Descriptors */
- int Am;
+ int An;
CHAMELEON_Complex64_t *A, *B, *C, *Cinit;
bump = run_arg_get_double( args, "bump", bump );
@@ -147,20 +147,15 @@ testing_zhemm_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Calculate the dimensions according to the side */
- if ( side == ChamLeft ) {
- Am = M;
- }
- else {
- Am = N;
- }
+ An = ( side == ChamLeft ) ? M : N;
/* Create the matrices */
- A = malloc( LDA*Am*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
- CHAMELEON_zplghe( bump, uplo, N, A, LDA, seedA );
+ CHAMELEON_zplghe( bump, uplo, An, A, LDA, seedA );
CHAMELEON_zplrnt( M, N, B, LDB, seedB );
CHAMELEON_zplrnt( M, N, C, LDC, seedC );
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index 79509cd08..3cde6694a 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -139,7 +139,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
double bump = testing_dalea();
/* Descriptors */
- int Am, An;
+ int Am, An, Bm, Bn;
CHAMELEON_Complex64_t *A, *B, *C, *Cinit;
bump = run_arg_get_double( args, "bump", bump );
@@ -152,20 +152,24 @@ testing_zher2k_std( run_arg_list_t *args, int check )
if ( trans == ChamNoTrans ) {
Am = N;
An = K;
+ Bm = N;
+ Bn = K;
}
else {
Am = K;
An = N;
+ Bm = K;
+ Bn = N;
}
/* Create the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*An*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fill the matrix with random values */
- CHAMELEON_zplrnt( Am, An, B, LDA, seedA );
- CHAMELEON_zplrnt( K, An, B, LDB, seedB );
+ CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
+ CHAMELEON_zplrnt( Bm, Bn, B, LDB, seedB );
CHAMELEON_zplghe( bump, uplo, N, C, LDC, seedC );
/* Calculate the product */
@@ -179,7 +183,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
- hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, B, LDA, beta, Cinit, C, LDC );
+ hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index 83ade364b..7cc8dbe29 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -162,14 +162,14 @@ testing_zherk_std( run_arg_list_t *args, int check )
testing_start( &test_data );
hres = CHAMELEON_zherk( uplo, trans, N, K, alpha, A, LDA, beta, C, LDC );
test_data.hres = hres;
- testing_stop( &test_data, flops_zherk( K, N ) );
+ testing_stop( &test_data, flops_zherk( N, K ) );
/* Checks the solution */
if ( check ) {
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
- hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, NULL, LDA, beta, Cinit, C, LDC );
+ hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, LDA, NULL, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
@@ -199,7 +199,7 @@ testing_zherk_init( void )
test_zherk.output = zherk_output;
test_zherk.outchk = zherk_outchk;
test_zherk.fptr_desc = testing_zherk_desc;
- test_zherk.fptr_std = NULL;
+ test_zherk.fptr_std = testing_zherk_std;
test_zherk.next = NULL;
testing_register( &test_zherk );
diff --git a/testing/testing_zposv.c b/testing/testing_zposv.c
index 89eaf2c77..f193f45f2 100644
--- a/testing/testing_zposv.c
+++ b/testing/testing_zposv.c
@@ -127,7 +127,7 @@ testing_zposv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( LDA*N *sizeof(CHAMELEON_Complex64_t) );
X = malloc( LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
@@ -148,7 +148,7 @@ testing_zposv_std( run_arg_list_t *args, int check )
/* Check the factorization */
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
- hres += check_zxxtrf_std( args, ChamHermitian, uplo, N, NRHS, A0, A, LDA );
+ hres += check_zxxtrf_std( args, ChamHermitian, uplo, N, N, A0, A, LDA );
/* Check the solve */
CHAMELEON_zplrnt( N, NRHS, B, LDB, seedB );
diff --git a/testing/testing_zpotrs.c b/testing/testing_zpotrs.c
index 5d6d95ec6..2130c2079 100644
--- a/testing/testing_zpotrs.c
+++ b/testing/testing_zpotrs.c
@@ -157,7 +157,7 @@ testing_t test_zpotrs;
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 };
+const char *zpotrs_outchk[] = { "||A||", "||A-fact(A)||", "||X||", "||B||", "||Ax-b||", "||Ax-b||/N/eps/(||A||||x||+||b||", "RETURN", NULL };
/**
* @brief Testing registration function
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index f87066a87..5e2bb66ce 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -137,7 +137,7 @@ testing_zsymm_std( run_arg_list_t *args, int check )
double bump = testing_dalea();
/* Descriptors */
- int Am;
+ int An;
CHAMELEON_Complex64_t *A, *B, *C, *Cinit;
bump = run_arg_get_double( args, "bump", bump );
@@ -147,26 +147,21 @@ testing_zsymm_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Calculate the dimensions according to the side */
- if ( side == ChamLeft ) {
- Am = M;
- }
- else {
- Am = N;
- }
+ An = ( side == ChamLeft ) ? M : N;
/* Create the matrices */
- A = malloc( LDA*Am*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
- CHAMELEON_zplgsy( bump, uplo, N, A, LDA, seedA );
+ CHAMELEON_zplgsy( bump, uplo, An, A, LDA, seedA );
CHAMELEON_zplrnt( M, N, B, LDB, seedB );
CHAMELEON_zplrnt( M, N, C, LDC, seedC );
/* Calculates the product */
testing_start( &test_data );
- hres = CHAMELEON_zsymm( side, uplo, Am, N, alpha, A, LDA, B, LDB, beta, C, LDC );
+ hres = CHAMELEON_zsymm( side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
testing_stop( &test_data, flops_zsymm( side, M, N ) );
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 1db847448..4a30d9115 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -139,7 +139,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
double bump = testing_dalea();
/* Descriptors */
- int Am, An;
+ int Am, An, Bm, Bn;
CHAMELEON_Complex64_t *A, *B, *C, *Cinit;
bump = run_arg_get_double( args, "bump", bump );
@@ -152,34 +152,38 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
if ( trans == ChamNoTrans ) {
Am = N;
An = K;
+ Bm = N;
+ Bn = K;
}
else {
Am = K;
An = N;
+ Bm = K;
+ Bn = N;
}
/* Create the matrices */
A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( LDB*An*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
C = malloc( LDC*N *sizeof(CHAMELEON_Complex64_t) );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
- CHAMELEON_zplrnt( Am, An, B, LDB, seedB );
+ CHAMELEON_zplrnt( Bm, Bn, B, LDB, seedB );
CHAMELEON_zplgsy( bump, uplo, N, C, LDC, seedC );
/* Calculate the product */
testing_start( &test_data );
hres = CHAMELEON_zsyr2k( uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, C, LDC );
test_data.hres = hres;
- testing_stop( &test_data, flops_zher2k( K, N ) );
+ testing_stop( &test_data, flops_zher2k( N, K ) );
/* Check the solution */
if ( check ) {
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
- hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, B, LDA, beta, Cinit, C, LDC );
+ hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
free( Cinit );
}
@@ -196,7 +200,7 @@ 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 };
+const char *zsyr2k_outchk[] = { "||A||", "||B||", "||C||", "||R||", "RETURN", NULL };
/**
* @brief Testing registration function
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index 87be0bd64..ccf584bbe 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -168,7 +168,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
Cinit = malloc( LDC*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
- hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, NULL, LDA, beta, Cinit, C, LDC );
+ hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, LDA, NULL, LDA, beta, Cinit, C, LDC );
free( Cinit );
}
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index 9809931fc..3cc1506d6 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -40,7 +40,7 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
int N = run_arg_get_int( args, "N", 1000 );
int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", N );
+ int LDA = run_arg_get_int( args, "LDA", ( side == ChamLeft ) ? M : N );
int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
@@ -56,12 +56,10 @@ testing_ztrmm_desc( run_arg_list_t *args, int check )
/* Calculates the dimensions according to the side */
if ( side == ChamLeft ) {
- LDA = M;
CHAMELEON_Desc_Create(
&descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, M, 0, 0, M, M, P, Q );
}
else {
- LDA = N;
CHAMELEON_Desc_Create(
&descA, (void*)(-mtxfmt), ChamComplexDouble, nb, nb, nb * nb, LDA, N, 0, 0, N, N, P, Q );
}
@@ -120,14 +118,14 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
int N = run_arg_get_int( args, "N", 1000 );
int M = run_arg_get_int( args, "M", N );
- int LDA = run_arg_get_int( args, "LDA", N );
+ int LDA = run_arg_get_int( args, "LDA", ( side == ChamLeft ) ? M : N );
int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
int seedB = run_arg_get_int( args, "seedB", random() );
/* Descriptors */
- int An;
+ int An;
CHAMELEON_Complex64_t *A, *B, *Binit;
alpha = run_arg_get_complex64( args, "alpha", alpha );
@@ -135,19 +133,11 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Calculates the dimensions according to the side */
- if ( side == ChamLeft ) {
- An = M;
- LDA = M;
- A = malloc( LDA*N *sizeof(CHAMELEON_Complex64_t) );
- }
- else {
- An = N;
- LDA = N;
- A = malloc( LDA*N *sizeof(CHAMELEON_Complex64_t) );
- }
+ An = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- B = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( An, An, A, LDA, seedA );
@@ -155,7 +145,7 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
/* Calculates the product */
testing_start( &test_data );
- hres = CHAMELEON_ztrmm( side, uplo, trans, diag, N, M, alpha, A, LDA, B, LDB );
+ hres = CHAMELEON_ztrmm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
test_data.hres = hres;
testing_stop( &test_data, flops_ztrmm( side, N, M ) );
@@ -164,7 +154,7 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
Binit = malloc( LDB*N*sizeof(CHAMELEON_Complex64_t) );
CHAMELEON_zplrnt( M, N, Binit, LDB, seedB );
- hres += check_ztrmm_std( args, CHECK_TRMM, side, uplo, trans, diag, N, M, alpha, A, LDA, B, Binit, LDB );
+ hres += check_ztrmm_std( args, CHECK_TRMM, side, uplo, trans, diag, M, N, alpha, A, LDA, B, Binit, LDB );
free( Binit );
}
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index 89cd4f733..fb683176a 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -112,8 +112,8 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
cham_diag_t diag = run_arg_get_diag( args, "diag", ChamNonUnit );
int N = run_arg_get_int( args, "N", 1000 );
int M = run_arg_get_int( args, "M", N );
- int Ak = ( side == ChamLeft ) ? M : N;
- int LDA = run_arg_get_int( args, "LDA", Ak );
+ int An = ( side == ChamLeft ) ? M : N;
+ int LDA = run_arg_get_int( args, "LDA", An );
int LDB = run_arg_get_int( args, "LDB", M );
CHAMELEON_Complex64_t alpha = testing_zalea();
int seedA = run_arg_get_int( args, "seedA", random() );
@@ -127,7 +127,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( LDA*Ak*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( LDA*An*sizeof(CHAMELEON_Complex64_t) );
B = malloc( LDB*N *sizeof(CHAMELEON_Complex64_t) );
/* Fills the matrix with random values */
@@ -137,7 +137,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
/* Calculates the product */
testing_start( &test_data );
- hres = CHAMELEON_ztrsm( side, uplo, trans, diag, N, M, alpha, A, LDA, B, LDB );
+ hres = CHAMELEON_ztrsm( side, uplo, trans, diag, M, N, alpha, A, LDA, B, LDB );
test_data.hres = hres;
testing_stop( &test_data, flops_ztrsm( side, M, N ) );
--
GitLab