From cafada272d62de0fdfc53a6de4a2d79a5f82ef6c Mon Sep 17 00:00:00 2001
From: Mathieu Faverge <mathieu.faverge@inria.fr>
Date: Tue, 28 Jan 2025 10:32:25 +0100
Subject: [PATCH] Try to move sizeof first in all allocation and memcpy,memset
functions
---
compute/pzlatms.c | 2 +-
compute/pzplrnk.c | 4 +-
compute/zgesvd.c | 4 +-
compute/zheevd.c | 10 ++---
control/descriptor.c | 2 +-
control/workspace.c | 2 +-
coreblas/compute/core_ztstrf.c | 2 +-
doc/user/homepage.org | 8 ++--
example/lapack_to_chameleon/step0.c | 14 +++---
example/lapack_to_chameleon/step1.c | 14 +++---
example/lapack_to_chameleon/step2.c | 12 ++---
example/lapack_to_chameleon/step3.c | 4 +-
example/lapack_to_chameleon/step3.h | 2 +-
example/lapack_to_chameleon/step4.c | 4 +-
example/lapack_to_chameleon/step5.c | 4 +-
example/lapack_to_chameleon/step6.c | 4 +-
example/lapack_to_chameleon/step7.c | 4 +-
example/mpi/comm_split.c | 2 +-
gpucublas/compute/cuda_zgelqt.c | 12 ++---
gpucublas/compute/cuda_zgeqrt.c | 12 ++---
gpucublas/compute/cuda_zparfb.c | 44 +++++++++----------
gpucublas/compute/cuda_ztslqt.c | 16 +++----
gpucublas/compute/cuda_ztsqrt.c | 30 ++++++-------
include/chameleon/getenv.h | 2 +-
runtime/parsec/codelets/codelet_map.c | 2 +-
runtime/quark/codelets/codelet_map.c | 2 +-
runtime/starpu/codelets/codelet_map.c | 2 +-
runtime/starpu/codelets/codelet_zgersum.c | 4 +-
.../starpu/codelets/codelet_zipiv_allreduce.c | 2 +-
runtime/starpu/interface/cppi_interface.c | 4 +-
testing/parameters.c | 2 +-
testing/testing_zcesca.c | 2 +-
testing/testing_zcheck_aux.c | 32 +++++++-------
testing/testing_zcheck_blas.c | 30 ++++++-------
testing/testing_zcheck_svd.c | 4 +-
testing/testing_zgeadd.c | 6 +--
testing/testing_zgelqf.c | 6 +--
testing/testing_zgelqf_hqr.c | 6 +--
testing/testing_zgels.c | 8 ++--
testing/testing_zgels_hqr.c | 8 ++--
testing/testing_zgemm.c | 8 ++--
testing/testing_zgenm2.c | 6 +--
testing/testing_zgepdf_qdwh.c | 6 +--
testing/testing_zgeqrf.c | 6 +--
testing/testing_zgeqrf_hqr.c | 6 +--
testing/testing_zgesv_nopiv.c | 8 ++--
testing/testing_zgesvd.c | 20 ++++-----
testing/testing_zgetrf.c | 8 ++--
testing/testing_zgetrf_nopiv.c | 4 +-
testing/testing_zgetrs_nopiv.c | 8 ++--
testing/testing_zgram.c | 2 +-
testing/testing_zhemm.c | 8 ++--
testing/testing_zher2k.c | 8 ++--
testing/testing_zherk.c | 6 +--
testing/testing_zlacpy.c | 4 +-
testing/testing_zlange.c | 2 +-
testing/testing_zlanhe.c | 2 +-
testing/testing_zlansy.c | 2 +-
testing/testing_zlantr.c | 2 +-
testing/testing_zlascal.c | 4 +-
testing/testing_zlauum.c | 4 +-
testing/testing_zplrnk.c | 2 +-
testing/testing_zpoinv.c | 4 +-
testing/testing_zposv.c | 8 ++--
testing/testing_zpotrf.c | 4 +-
testing/testing_zpotri.c | 4 +-
testing/testing_zpotrs.c | 8 ++--
testing/testing_zsymm.c | 8 ++--
testing/testing_zsyr2k.c | 8 ++--
testing/testing_zsyrk.c | 6 +--
testing/testing_zsysv.c | 8 ++--
testing/testing_zsytrf.c | 4 +-
testing/testing_zsytrs.c | 8 ++--
testing/testing_ztradd.c | 6 +--
testing/testing_ztrmm.c | 6 +--
testing/testing_ztrsm.c | 6 +--
testing/testing_ztrtri.c | 4 +-
testing/testing_zunglq.c | 6 +--
testing/testing_zunglq_hqr.c | 6 +--
testing/testing_zungqr.c | 6 +--
testing/testing_zungqr_hqr.c | 6 +--
testing/testing_zunmlq.c | 8 ++--
testing/testing_zunmlq_hqr.c | 8 ++--
testing/testing_zunmqr.c | 8 ++--
testing/testing_zunmqr_hqr.c | 8 ++--
85 files changed, 304 insertions(+), 304 deletions(-)
diff --git a/compute/pzlatms.c b/compute/pzlatms.c
index 7e6fd24e3..a672d026a 100644
--- a/compute/pzlatms.c
+++ b/compute/pzlatms.c
@@ -121,7 +121,7 @@ void chameleon_pzlatms( cham_dist_t idist, unsigned long long int seed, cham_sym
#endif
if ( D == NULL ) {
- D = malloc( minmn * sizeof(double) );
+ D = malloc( sizeof(double) * minmn );
alloc_d = 1;
}
rc = CORE_dlatm1( mode, cond, irsign, idist, seed, D, minmn );
diff --git a/compute/pzplrnk.c b/compute/pzplrnk.c
index 97e7c8bdc..610ab8d38 100644
--- a/compute/pzplrnk.c
+++ b/compute/pzplrnk.c
@@ -42,7 +42,7 @@ chameleon_pzplrnk_generic( CHAM_context_t *chamctxt,
int tempmm, tempnn, tempkk;
int myrank = RUNTIME_comm_rank( chamctxt );
int initA;
- int *initB = malloc( C->nt * sizeof(int) );
+ int *initB = malloc( sizeof(int) * C->nt );
KT = (K + C->mb - 1) / C->mb;
@@ -50,7 +50,7 @@ chameleon_pzplrnk_generic( CHAM_context_t *chamctxt,
tempkk = k == KT-1 ? K - k * WA->nb : WA->nb;
zbeta = k == 0 ? 0. : 1.;
- memset( initB, 0, C->nt * sizeof(int) );
+ memset( initB, 0, sizeof(int) * C->nt );
for (m = 0; m < C->mt; m++) {
tempmm = C->get_blkdim( C, m, DIM_m, C->m );
diff --git a/compute/zgesvd.c b/compute/zgesvd.c
index 9528a28d7..bcac0fa9c 100644
--- a/compute/zgesvd.c
+++ b/compute/zgesvd.c
@@ -472,13 +472,13 @@ int CHAMELEON_zgesvd_Tile_Async( cham_job_t jobu, cham_job_t jobvt,
}
#endif
- E = malloc( MINMN * sizeof(double) );
+ E = malloc( sizeof(double) * MINMN );
if ( E == NULL ) {
chameleon_error( "CHAMELEON_zgesvd_Tile_Async", "malloc(E) failed" );
free( E );
return CHAMELEON_ERR_OUT_OF_RESOURCES;
}
- memset( E, 0, MINMN * sizeof(double) );
+ memset( E, 0, sizeof(double) * MINMN );
/* Reduction to band + bidiagonal */
diff --git a/compute/zheevd.c b/compute/zheevd.c
index 510346b7a..6f2c4fc06 100644
--- a/compute/zheevd.c
+++ b/compute/zheevd.c
@@ -400,7 +400,7 @@ int CHAMELEON_zheevd_Tile_Async( cham_job_t jobz, cham_uplo_t uplo,
NB = descA.mb;
/* Allocate data structures for reduction to tridiagonal form */
- E = malloc( (N - 1) * sizeof(double) );
+ E = malloc( sizeof(double) * (N - 1) );
if (E == NULL) {
chameleon_error("CHAMELEON_zheevd_Tile_Async", "malloc(E) failed");
free(E);
@@ -409,9 +409,9 @@ int CHAMELEON_zheevd_Tile_Async( cham_job_t jobz, cham_uplo_t uplo,
if (jobz == ChamVec){
/* Have to synchrone right now */
- Q2 = malloc( N * N * sizeof(CHAMELEON_Complex64_t));
+ Q2 = malloc( sizeof(CHAMELEON_Complex64_t) * N * N );
/* For bug in lapacke */
- memset( Q2, 0, N * N * sizeof(CHAMELEON_Complex64_t));
+ memset( Q2, 0, sizeof(CHAMELEON_Complex64_t) * N * N );
}
status = CHAMELEON_zhetrd_Tile_Async( jobz, uplo,
@@ -437,7 +437,7 @@ int CHAMELEON_zheevd_Tile_Async( cham_job_t jobz, cham_uplo_t uplo,
return CHAMELEON_SUCCESS;
}
- V = malloc( N * N * sizeof(CHAMELEON_Complex64_t) );
+ V = malloc( sizeof(CHAMELEON_Complex64_t) * N * N );
if (V == NULL) {
chameleon_error("CHAMELEON_zheevd_Tile_Async", "malloc(V) failed");
free(E);
@@ -446,7 +446,7 @@ int CHAMELEON_zheevd_Tile_Async( cham_job_t jobz, cham_uplo_t uplo,
return CHAMELEON_ERR_OUT_OF_RESOURCES;
}
/* For bug in lapacke */
- memset(V, 0, N * N * sizeof(CHAMELEON_Complex64_t));
+ memset(V, 0, sizeof(CHAMELEON_Complex64_t) * N * N );
/*
* Tridiagonal eigensolver
diff --git a/control/descriptor.c b/control/descriptor.c
index 4a1f2ef00..ce86f785c 100644
--- a/control/descriptor.c
+++ b/control/descriptor.c
@@ -97,7 +97,7 @@ void chameleon_desc_init_tiles( CHAM_desc_t *desc, blkrankof_fct_t rankof )
int ii, jj;
assert( rankof != chameleon_getrankof_tile );
- desc->tiles = malloc( desc->lmt * desc->lnt * sizeof(CHAM_tile_t) );
+ desc->tiles = malloc( sizeof(CHAM_tile_t) * desc->lmt * desc->lnt );
tile = desc->tiles;
for( jj=0; jj<desc->lnt; jj++ ) {
diff --git a/control/workspace.c b/control/workspace.c
index 05706af51..ec8a4e833 100644
--- a/control/workspace.c
+++ b/control/workspace.c
@@ -111,7 +111,7 @@ int chameleon_alloc_ipiv(int M, int N, cham_tasktype_t func, int type, CHAM_desc
lm = (int64_t)IB * (int64_t)MT;
ln = (int64_t)NB * (int64_t)NT;
- size = (size_t)(chameleon_min(MT, NT) * NB * NT * sizeof(int));
+ size = (size_t)(sizeof(int) * chameleon_min(MT, NT) * NB * NT);
if (size == 0) {
*IPIV = NULL;
return CHAMELEON_SUCCESS;
diff --git a/coreblas/compute/core_ztstrf.c b/coreblas/compute/core_ztstrf.c
index 10930a256..b9a7038c4 100644
--- a/coreblas/compute/core_ztstrf.c
+++ b/coreblas/compute/core_ztstrf.c
@@ -141,7 +141,7 @@ int CORE_ztstrf(int M, int N, int IB, int NB,
return CHAMELEON_SUCCESS;
/* Set L to 0 */
- memset(L, 0, LDL*N*sizeof(CHAMELEON_Complex64_t));
+ memset( L, 0, sizeof(CHAMELEON_Complex64_t) * LDL * N );
ip = 0;
for (ii = 0; ii < N; ii += IB) {
diff --git a/doc/user/homepage.org b/doc/user/homepage.org
index 2bf41a44e..39c060adf 100644
--- a/doc/user/homepage.org
+++ b/doc/user/homepage.org
@@ -402,9 +402,9 @@
* - set of RHS vectors B : size N x NRHS
* - set of solutions vectors X : size N x NRHS
*/
- double *A = malloc( N * N * sizeof(double) );
- double *B = malloc( N * NRHS * sizeof(double) );
- double *X = malloc( N * NRHS * sizeof(double) );
+ double *A = malloc( sizeof(double) * N * N );
+ double *B = malloc( sizeof(double) * N * NRHS );
+ double *X = malloc( sizeof(double) * N * NRHS );
/* generate A matrix with random values such that it is spd */
CHAMELEON_dplgsy( (double)N, ChamUpperLower, N, A, N, 51 );
@@ -413,7 +413,7 @@
CHAMELEON_dplrnt( N, NRHS, B, N, 5673 );
/* copy B in X before solving */
- memcpy(X, B, N*NRHS*sizeof(double));
+ memcpy( X, B, sizeof(double) * N * NRHS );
/************************************************************/
/* solve the system AX = B using the Cholesky factorization */
diff --git a/example/lapack_to_chameleon/step0.c b/example/lapack_to_chameleon/step0.c
index 067f6693d..7638428af 100644
--- a/example/lapack_to_chameleon/step0.c
+++ b/example/lapack_to_chameleon/step0.c
@@ -41,7 +41,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -70,10 +70,10 @@ int main(int argc, char *argv[]) {
* - set of RHS vectors B : size N x NRHS
* - set of solutions vectors X : size N x NRHS
*/
- double *A = malloc( N * N * sizeof(double) );
- double *Acpy = malloc( N * N * sizeof(double) );
- double *B = malloc( N * NRHS * sizeof(double) );
- double *X = malloc( N * NRHS * sizeof(double) );
+ double *A = malloc( sizeof(double) * N * N );
+ double *Acpy = malloc( sizeof(double) * N * N );
+ double *B = malloc( sizeof(double) * N * NRHS );
+ double *X = malloc( sizeof(double) * N * NRHS );
/* generate A matrix with random values such that it is spd */
CORE_dplgsy( (double)N, N, N, A, N, N, N, N, 51 );
@@ -82,10 +82,10 @@ int main(int argc, char *argv[]) {
CORE_dplrnt( N, NRHS, B, N, N, N, NRHS, 5673 );
/* copy A before facto. in order to check the result */
- memcpy(Acpy, A, N * N * sizeof(double));
+ memcpy( Acpy, A, sizeof(double) * N * N );
/* copy B in X before solving */
- memcpy(X, B, N*NRHS*sizeof(double));
+ memcpy( X, B, sizeof(double) * N * NRHS );
/************************************************************/
/* solve the system AX = B using the Cholesky factorization */
diff --git a/example/lapack_to_chameleon/step1.c b/example/lapack_to_chameleon/step1.c
index aba81ab31..fbae30a55 100644
--- a/example/lapack_to_chameleon/step1.c
+++ b/example/lapack_to_chameleon/step1.c
@@ -55,7 +55,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset(iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -92,10 +92,10 @@ int main(int argc, char *argv[]) {
* - set of RHS vectors B : size N x NRHS
* - set of solutions vectors X : size N x NRHS
*/
- double *A = malloc( N * N * sizeof(double) );
- double *Acpy = malloc( N * N * sizeof(double) );
- double *B = malloc( N * NRHS * sizeof(double) );
- double *X = malloc( N * NRHS * sizeof(double) );
+ double *A = malloc( sizeof(double) * N * N );
+ double *Acpy = malloc( sizeof(double) * N * N );
+ double *B = malloc( sizeof(double) * N * NRHS );
+ double *X = malloc( sizeof(double) * N * NRHS );
/* generate A matrix with random values such that it is spd */
CHAMELEON_dplgsy( (double)N, ChamUpperLower, N, A, N, 51 );
@@ -104,10 +104,10 @@ int main(int argc, char *argv[]) {
CHAMELEON_dplrnt( N, NRHS, B, N, 5673 );
/* copy A before facto. in order to check the result */
- memcpy(Acpy, A, N*N*sizeof(double));
+ memcpy( Acpy, A, sizeof(double) * N * N );
/* copy B in X before solving */
- memcpy(X, B, N*NRHS*sizeof(double));
+ memcpy( X, B, sizeof(double) * N * NRHS );
/************************************************************/
/* solve the system AX = B using the Cholesky factorization */
diff --git a/example/lapack_to_chameleon/step2.c b/example/lapack_to_chameleon/step2.c
index f89c2b017..e59746269 100644
--- a/example/lapack_to_chameleon/step2.c
+++ b/example/lapack_to_chameleon/step2.c
@@ -50,7 +50,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -90,10 +90,10 @@ int main(int argc, char *argv[]) {
* - set of RHS vectors B : size N x NRHS
* - set of solutions vectors X : size N x NRHS
*/
- double *A = malloc( N * N * sizeof(double) );
- double *Acpy = malloc( N * N * sizeof(double) );
- double *B = malloc( N * NRHS * sizeof(double) );
- double *X = malloc( N * NRHS * sizeof(double) );
+ double *A = malloc( sizeof(double) * N * N );
+ double *Acpy = malloc( sizeof(double) * N * N );
+ double *B = malloc( sizeof(double) * N * NRHS );
+ double *X = malloc( sizeof(double) * N * NRHS );
/*
* Initialize the structure required for CHAMELEON tile interface
@@ -143,7 +143,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/lapack_to_chameleon/step3.c b/example/lapack_to_chameleon/step3.c
index b472e0725..30caf368f 100644
--- a/example/lapack_to_chameleon/step3.c
+++ b/example/lapack_to_chameleon/step3.c
@@ -52,7 +52,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -135,7 +135,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/lapack_to_chameleon/step3.h b/example/lapack_to_chameleon/step3.h
index 1fe156e99..76db96fd6 100644
--- a/example/lapack_to_chameleon/step3.h
+++ b/example/lapack_to_chameleon/step3.h
@@ -127,7 +127,7 @@ double **allocate_tile_matrix(int m, int n, int nb){
/* compute number of tiles in rows and columns */
mt = (m%nb==0) ? (m/nb) : (m/nb+1);
nt = (n%nb==0) ? (n/nb) : (n/nb+1);
- mat = malloc( mt*nt*sizeof(double*) );
+ mat = malloc( sizeof(double*) * mt * nt );
if (!mat){
printf ("\nIn allocate_tile_matrix, memory Allocation Failure of mat !\n\n");
exit (EXIT_FAILURE);
diff --git a/example/lapack_to_chameleon/step4.c b/example/lapack_to_chameleon/step4.c
index 070fdb23a..311a97304 100644
--- a/example/lapack_to_chameleon/step4.c
+++ b/example/lapack_to_chameleon/step4.c
@@ -58,7 +58,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -112,7 +112,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/lapack_to_chameleon/step5.c b/example/lapack_to_chameleon/step5.c
index 84bd27fa6..ecfee8683 100644
--- a/example/lapack_to_chameleon/step5.c
+++ b/example/lapack_to_chameleon/step5.c
@@ -58,7 +58,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -116,7 +116,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/lapack_to_chameleon/step6.c b/example/lapack_to_chameleon/step6.c
index 76a2b4fa0..9a0c355a4 100644
--- a/example/lapack_to_chameleon/step6.c
+++ b/example/lapack_to_chameleon/step6.c
@@ -59,7 +59,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -138,7 +138,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/lapack_to_chameleon/step7.c b/example/lapack_to_chameleon/step7.c
index a9c5431c6..3eac607c8 100644
--- a/example/lapack_to_chameleon/step7.c
+++ b/example/lapack_to_chameleon/step7.c
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
@@ -167,7 +167,7 @@ int main(int argc, char *argv[]) {
CHAMELEON_dlacpy_Tile(ChamUpperLower, descA, descAC);
/* copy B in X before solving
- * same sense as memcpy(X, B, N*NRHS*sizeof(double)) but for descriptors */
+ * same sense as memcpy( X, B, sizeof(double) * N * NRHS ) but for descriptors */
CHAMELEON_dlacpy_Tile(ChamUpperLower, descB, descX);
/************************************************************/
diff --git a/example/mpi/comm_split.c b/example/mpi/comm_split.c
index 4b167ac13..62685d339 100644
--- a/example/mpi/comm_split.c
+++ b/example/mpi/comm_split.c
@@ -83,7 +83,7 @@ int main(int argc, char *argv[]) {
/* initialize some parameters with default values */
int iparam[IPARAM_SIZEOF];
- memset(iparam, 0, IPARAM_SIZEOF*sizeof(int));
+ memset( iparam, 0, sizeof(int) * IPARAM_SIZEOF );
init_iparam(iparam);
/* read arguments */
diff --git a/gpucublas/compute/cuda_zgelqt.c b/gpucublas/compute/cuda_zgelqt.c
index 5407d587e..c183781e1 100644
--- a/gpucublas/compute/cuda_zgelqt.c
+++ b/gpucublas/compute/cuda_zgelqt.c
@@ -34,10 +34,10 @@ int CUDA_zgelqt(
magmaDoubleComplex *dwork,
CUstream stream)
{
-#define da_ref(a_1,a_2) ( da+(a_2)*(ldda) + (a_1))
-#define v_ref(a_1,a_2) ( v+(a_2)*(ldv) + (a_1))
-#define dt_ref(a_1,a_2) ( dt+(a_2)*(lddt) + (a_1))
-#define t_ref(a_1,a_2) ( t+(a_2)*(ldt) + (a_1))
+#define da_ref(a_1,a_2) ( da+(size_t)(a_2)*(ldda) + (a_1))
+#define v_ref(a_1,a_2) ( v +(size_t)(a_2)*(ldv) + (a_1))
+#define dt_ref(a_1,a_2) ( dt+(size_t)(a_2)*(lddt) + (a_1))
+#define t_ref(a_1,a_2) ( t +(size_t)(a_2)*(ldt) + (a_1))
int i, k, ib, old_i, old_ib, rows, cols;
double _Complex one=1.;
@@ -57,8 +57,8 @@ int CUDA_zgelqt(
}
/* lower parts of little T must be zero: memset to 0 for simplicity */
- memset(t_ref(0,0), 0, nb*n*sizeof(magmaDoubleComplex));
- cudaMemsetAsync(dt_ref(0,0), 0, nb*n*sizeof(magmaDoubleComplex), stream);
+ memset( t_ref(0,0), 0, sizeof(magmaDoubleComplex) * nb * n );
+ cudaMemsetAsync( dt_ref(0,0), 0, sizeof(magmaDoubleComplex) * nb * n, stream );
if ( (nb > 1) && (nb < k) ) {
/* Use blocked code initially */
diff --git a/gpucublas/compute/cuda_zgeqrt.c b/gpucublas/compute/cuda_zgeqrt.c
index c995e883e..17c8649e6 100644
--- a/gpucublas/compute/cuda_zgeqrt.c
+++ b/gpucublas/compute/cuda_zgeqrt.c
@@ -35,10 +35,10 @@ CUDA_zgeqrt(
magmaDoubleComplex *dwork,
CUstream stream )
{
-#define da_ref(a_1,a_2) ( da+(a_2)*(ldda) + (a_1))
-#define v_ref(a_1,a_2) ( v+(a_2)*(ldv) + (a_1))
-#define dt_ref(a_1,a_2) ( dt+(a_2)*(lddt) + (a_1))
-#define t_ref(a_1,a_2) ( t+(a_2)*(ldt) + (a_1))
+#define da_ref(a_1,a_2) ( da+(size_t)(a_2)*(ldda) + (a_1))
+#define v_ref( a_1,a_2) ( v +(size_t)(a_2)*(ldv) + (a_1))
+#define dt_ref(a_1,a_2) ( dt+(size_t)(a_2)*(lddt) + (a_1))
+#define t_ref( a_1,a_2) ( t +(size_t)(a_2)*(ldt) + (a_1))
int i, k, ib, old_i, old_ib, rows, cols;
double _Complex one=1.;
@@ -58,8 +58,8 @@ CUDA_zgeqrt(
}
/* lower parts of little T must be zero: memset to 0 for simplicity */
- memset(t_ref(0,0), 0, nb*n*sizeof(magmaDoubleComplex));
- cudaMemsetAsync(dt_ref(0,0), 0, nb*n*sizeof(magmaDoubleComplex), stream);
+ memset( t_ref(0,0), 0, sizeof(magmaDoubleComplex) * nb * n );
+ cudaMemsetAsync( dt_ref(0,0), 0, sizeof(magmaDoubleComplex) * nb * n, stream );
if ( (nb > 1) && (nb < k) ) {
/* Use blocked code initially */
diff --git a/gpucublas/compute/cuda_zparfb.c b/gpucublas/compute/cuda_zparfb.c
index 9f3a665bd..df2f8c888 100644
--- a/gpucublas/compute/cuda_zparfb.c
+++ b/gpucublas/compute/cuda_zparfb.c
@@ -263,16 +263,16 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
/*
* Backup V, and put 0 in the lower part
*/
- cudaMemcpy2DAsync( workV, ldV * sizeof(cuDoubleComplex),
- V, LDV * sizeof(cuDoubleComplex),
- M2 * sizeof(cuDoubleComplex), K,
+ cudaMemcpy2DAsync( workV, sizeof(cuDoubleComplex) * ldV,
+ V, sizeof(cuDoubleComplex) * LDV,
+ sizeof(cuDoubleComplex) * M2, K,
cudaMemcpyDeviceToDevice, stream );
j = 0;
i = M2 - L + 1;
for(; (i < M2) && (j < K); i++, j++ ) {
cudaMemsetAsync( workV + j * ldV + i, 0,
- (M2 - i) * sizeof(cuDoubleComplex),
+ sizeof(cuDoubleComplex) * (M2 - i),
stream );
}
}
@@ -282,14 +282,14 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
/*
* Backup V, and put 0 in the upper part
*/
- cudaMemcpy2DAsync( workV, ldV * sizeof(cuDoubleComplex),
- V, LDV * sizeof(cuDoubleComplex),
- K * sizeof(cuDoubleComplex), M2,
+ cudaMemcpy2DAsync( workV, sizeof(cuDoubleComplex) * ldV,
+ V, sizeof(cuDoubleComplex) * LDV,
+ sizeof(cuDoubleComplex) * K, M2,
cudaMemcpyDeviceToDevice, stream );
for(j = 1; j < K; j++) {
cudaMemsetAsync( workV + ldV * ( M2 - L + j ), 0,
- j * sizeof(cuDoubleComplex),
+ sizeof(cuDoubleComplex) * j,
stream );
}
}
@@ -301,9 +301,9 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
* W = W + V' * A2
*
*/
- cudaMemcpy2DAsync( workW, ldW * sizeof(cuDoubleComplex),
- A1, LDA1 * sizeof(cuDoubleComplex),
- K * sizeof(cuDoubleComplex), N1,
+ cudaMemcpy2DAsync( workW, sizeof(cuDoubleComplex) * ldW,
+ A1, sizeof(cuDoubleComplex) * LDA1,
+ sizeof(cuDoubleComplex) * K, N1,
cudaMemcpyDeviceToDevice, stream );
transW = storev == ChamColumnwise ? ChamConjTrans : ChamNoTrans;
@@ -418,16 +418,16 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
/*
* Backup V, and put 0 in the lower part
*/
- cudaMemcpy2DAsync( workV, ldV * sizeof(cuDoubleComplex),
- V, LDV * sizeof(cuDoubleComplex),
- N2 * sizeof(cuDoubleComplex), K,
+ cudaMemcpy2DAsync( workV, sizeof(cuDoubleComplex) * ldV,
+ V, sizeof(cuDoubleComplex) * LDV,
+ sizeof(cuDoubleComplex) * N2, K,
cudaMemcpyDeviceToDevice, stream );
j = 0;
i = N2 - L + 1;
for(; (i < N2) && (j < K); i++, j++ ) {
cudaMemsetAsync( workV + j * ldV + i, 0,
- (N2 - i) * sizeof(cuDoubleComplex),
+ sizeof(cuDoubleComplex) * (N2 - i),
stream );
}
}
@@ -437,14 +437,14 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
/*
* Backup V, and put 0 in the upper part
*/
- cudaMemcpy2DAsync( workV, ldV * sizeof(cuDoubleComplex),
- V, LDV * sizeof(cuDoubleComplex),
- K * sizeof(cuDoubleComplex), N2,
+ cudaMemcpy2DAsync( workV, sizeof(cuDoubleComplex) * ldV,
+ V, sizeof(cuDoubleComplex) * LDV,
+ sizeof(cuDoubleComplex) * K, N2,
cudaMemcpyDeviceToDevice, stream );
for(j = 1; j < K; j++) {
cudaMemsetAsync( workV + ldV * ( N2 - L + j ), 0,
- j * sizeof(cuDoubleComplex),
+ sizeof(cuDoubleComplex) * j,
stream );
}
}
@@ -456,9 +456,9 @@ CUDA_zparfb( cham_side_t side, cham_trans_t trans,
* W = W + A2 * V'
*
*/
- cudaMemcpy2DAsync( workW, ldW * sizeof(cuDoubleComplex),
- A1, LDA1 * sizeof(cuDoubleComplex),
- M1 * sizeof(cuDoubleComplex), K,
+ cudaMemcpy2DAsync( workW, sizeof(cuDoubleComplex) * ldW,
+ A1, sizeof(cuDoubleComplex) * LDA1,
+ sizeof(cuDoubleComplex) * M1, K,
cudaMemcpyDeviceToDevice, stream );
transW = storev == ChamColumnwise ? ChamNoTrans : ChamConjTrans;
diff --git a/gpucublas/compute/cuda_ztslqt.c b/gpucublas/compute/cuda_ztslqt.c
index dcd01f19d..d5f581466 100644
--- a/gpucublas/compute/cuda_ztslqt.c
+++ b/gpucublas/compute/cuda_ztslqt.c
@@ -35,12 +35,12 @@ int CUDA_ztslqt(
magmaDoubleComplex *dwork,
CUstream stream)
{
-#define da1_ref(a_1,a_2) ( da1+(a_2)*ldda1 + (a_1))
-#define da2_ref(a_1,a_2) ( da2+(a_2)*ldda2 + (a_1))
-#define a2_ref(a_1,a_2) ( a2+(a_2)*lda2 + (a_1))
-#define t_ref(a_1,a_2) ( t+(a_2)*ldt + (a_1))
-#define dt_ref(a_1,a_2) ( dt+(a_2)*lddt + (a_1))
-#define d_ref(a_1,a_2) ( d+(a_2)*ldd + (a_1))
+#define da1_ref(a_1,a_2) ( da1+(size_t)(a_2)*ldda1 + (a_1))
+#define da2_ref(a_1,a_2) ( da2+(size_t)(a_2)*ldda2 + (a_1))
+#define a2_ref( a_1,a_2) ( a2 +(size_t)(a_2)*lda2 + (a_1))
+#define t_ref( a_1,a_2) ( t +(size_t)(a_2)*ldt + (a_1))
+#define dt_ref( a_1,a_2) ( dt +(size_t)(a_2)*lddt + (a_1))
+#define d_ref( a_1,a_2) ( d +(size_t)(a_2)*ldd + (a_1))
int i, k, lddwork, old_i, old_ib, rows, cols;
int ib;
@@ -63,8 +63,8 @@ int CUDA_ztslqt(
lddwork= m;
/* lower parts of little T must be zero: memset all to 0 for simplicity */
- memset(t, 0, nb*n*sizeof(magmaDoubleComplex));
- cudaMemset(dt, 0, nb*n*sizeof(magmaDoubleComplex));
+ memset( t, 0, sizeof(magmaDoubleComplex) * nb * n );
+ cudaMemset( dt, 0, sizeof(magmaDoubleComplex) * nb * n );
//k = chameleon_min(m, nb); // m can be lower than IB
/* copy the first diag tile of A1 from device to host: da1 -> d */
diff --git a/gpucublas/compute/cuda_ztsqrt.c b/gpucublas/compute/cuda_ztsqrt.c
index a2c06235d..950d1f9c2 100644
--- a/gpucublas/compute/cuda_ztsqrt.c
+++ b/gpucublas/compute/cuda_ztsqrt.c
@@ -35,12 +35,12 @@ int CUDA_ztsqrt(
magmaDoubleComplex *dwork,
CUstream stream)
{
-#define da1_ref(a_1,a_2) ( da1+(a_2)*ldda1 + (a_1))
-#define da2_ref(a_1,a_2) ( da2+(a_2)*ldda2 + (a_1))
-#define a2_ref(a_1,a_2) ( a2+(a_2)*lda2 + (a_1))
-#define t_ref(a_1,a_2) ( t+(a_2)*ldt + (a_1))
-#define dt_ref(a_1,a_2) ( dt+(a_2)*lddt + (a_1))
-#define d_ref(a_1,a_2) ( d+(a_2)*ldd + (a_1))
+#define da1_ref(a_1,a_2) ( da1+(size_t)(a_2)*ldda1 + (a_1))
+#define da2_ref(a_1,a_2) ( da2+(size_t)(a_2)*ldda2 + (a_1))
+#define a2_ref( a_1,a_2) ( a2 +(size_t)(a_2)*lda2 + (a_1))
+#define t_ref( a_1,a_2) ( t +(size_t)(a_2)*ldt + (a_1))
+#define dt_ref( a_1,a_2) ( dt +(size_t)(a_2)*lddt + (a_1))
+#define d_ref( a_1,a_2) ( d +(size_t)(a_2)*ldd + (a_1))
int i, k, lddwork, old_i, old_ib, rows, cols;
int ib;
@@ -65,15 +65,15 @@ int CUDA_ztsqrt(
lddwork= nb;
/* lower parts of little T must be zero: memset all to 0 for simplicity */
- memset(t, 0, nb*nb*sizeof(magmaDoubleComplex));
- cudaMemset(dt, 0, nb*n*sizeof(magmaDoubleComplex));
+ memset( t, 0, sizeof(magmaDoubleComplex) * nb * nb );
+ cudaMemset( dt, 0, sizeof(magmaDoubleComplex) nb * n );
/* copy the first diag tile of A1 from device to host: da1 -> d */
cublasGetMatrix(nb, nb, sizeof(magmaDoubleComplex),
da1_ref(0, 0), ldda1,
d, ldd);
// cudaMemcpy( d, da1_ref(0,0),
-// nb*nb*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * nb * nb,
// cudaMemcpyDeviceToHost );
/* copy first panel of A2 from device to host: da2 -> a2 */
@@ -81,7 +81,7 @@ int CUDA_ztsqrt(
// da2_ref(0, 0), ldda2,
// a2, lda2);
cudaMemcpy( a2, da2_ref(0, 0),
- m*nb*sizeof(cuDoubleComplex),
+ sizeof(cuDoubleComplex) * m * nb,
cudaMemcpyDeviceToHost );
/* This is only blocked code for now */
@@ -100,7 +100,7 @@ int CUDA_ztsqrt(
da1_ref(i, i), ldda1,
d, ldd);
// cudaMemcpy( d, da1_ref(i,i),
-// ib*ib*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * ib * ib,
// cudaMemcpyDeviceToHost );
/* copy panel of A2 from device to host: da2 -> a2 */
@@ -108,7 +108,7 @@ int CUDA_ztsqrt(
da2_ref(0, i), ldda2,
a2, lda2);
// cudaMemcpy( a2, da2_ref(0,i),
-// rows*ib*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * rows * ib,
// cudaMemcpyDeviceToHost );
/* Apply H' to A(i:m,i+2*ib:n) from the left */
@@ -141,7 +141,7 @@ int CUDA_ztsqrt(
a2, lda2,
da2_ref(0, i), ldda2);
// cudaMemcpy( da2_ref(0,i), a2,
-// rows*ib*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * rows * ib,
// cudaMemcpyHostToDevice );
/* Send the triangular factor T from hwork to the GPU */
@@ -149,7 +149,7 @@ int CUDA_ztsqrt(
t, ldt,
dt_ref(0, i), lddt);
// cudaMemcpy( dt_ref(0,i), t,
-// ib*ib*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * ib * ib,
// cudaMemcpyHostToDevice );
/* get back the diag tile in A1 from host to device: d -> da1 */
@@ -157,7 +157,7 @@ int CUDA_ztsqrt(
d, ldd,
da1_ref(i, i), ldda1);
// cudaMemcpy( da1_ref(i, i), d,
-// ib*ib*sizeof(cuDoubleComplex),
+// sizeof(cuDoubleComplex) * ib * ib,
// cudaMemcpyHostToDevice );
/* tsmqr update on one panel forward (look ahead 1) */
diff --git a/include/chameleon/getenv.h b/include/chameleon/getenv.h
index 74c8ecc87..5656d7101 100644
--- a/include/chameleon/getenv.h
+++ b/include/chameleon/getenv.h
@@ -49,7 +49,7 @@ chameleon_getenv( const char *var ) {
char *str;
int len = 512;
int rc;
- str = (char*)malloc(len * sizeof(char));
+ str = (char*)malloc( sizeof(char) * len );
rc = GetEnvironmentVariable(var, str, len);
if (rc == 0) {
free(str);
diff --git a/runtime/parsec/codelets/codelet_map.c b/runtime/parsec/codelets/codelet_map.c
index d14ee9996..6cb009e52 100644
--- a/runtime/parsec/codelets/codelet_map.c
+++ b/runtime/parsec/codelets/codelet_map.c
@@ -136,7 +136,7 @@ void INSERT_TASK_map( const RUNTIME_option_t *options,
return;
}
- pargs_size = sizeof( struct parsec_map_args_s ) + (ndata - 1) * sizeof( CHAM_desc_t * );
+ pargs_size = sizeof( struct parsec_map_args_s ) + sizeof( CHAM_desc_t * ) * (ndata - 1);
pargs = malloc( pargs_size );
pargs->uplo = uplo;
pargs->m = m;
diff --git a/runtime/quark/codelets/codelet_map.c b/runtime/quark/codelets/codelet_map.c
index b7930ff71..cf1916f2b 100644
--- a/runtime/quark/codelets/codelet_map.c
+++ b/runtime/quark/codelets/codelet_map.c
@@ -80,7 +80,7 @@ void INSERT_TASK_map( const RUNTIME_option_t *options,
return;
}
- qargs_size = sizeof( struct quark_map_args_s ) + (ndata - 1) * sizeof( CHAM_desc_t * );
+ qargs_size = sizeof( struct quark_map_args_s ) + sizeof( CHAM_desc_t * ) * (ndata - 1);
qargs = malloc( qargs_size );
qargs->uplo = uplo;
qargs->m = m;
diff --git a/runtime/starpu/codelets/codelet_map.c b/runtime/starpu/codelets/codelet_map.c
index 0e9120cd3..4e7d1615f 100644
--- a/runtime/starpu/codelets/codelet_map.c
+++ b/runtime/starpu/codelets/codelet_map.c
@@ -258,7 +258,7 @@ void INSERT_TASK_map( const RUNTIME_option_t *options,
CHAMELEON_END_ACCESS_DECLARATION;
if ( exec ) {
- clargs_size = sizeof( struct cl_map_args_s ) + (ndata - 1) * sizeof( CHAM_desc_t * );
+ clargs_size = sizeof( struct cl_map_args_s ) + sizeof( CHAM_desc_t * ) * (ndata - 1);
clargs = malloc( clargs_size );
clargs->uplo = uplo;
clargs->m = m;
diff --git a/runtime/starpu/codelets/codelet_zgersum.c b/runtime/starpu/codelets/codelet_zgersum.c
index 8e5223087..b249d7756 100644
--- a/runtime/starpu/codelets/codelet_zgersum.c
+++ b/runtime/starpu/codelets/codelet_zgersum.c
@@ -98,8 +98,8 @@ cl_zgersum_init_cuda_func( void *descr[], void *cl_arg )
tileA = cti_interface_get(descr[0]);
- rc = cudaMemset2D( tileA->mat, tileA->ld * sizeof(CHAMELEON_Complex64_t), 0,
- tileA->m * sizeof(CHAMELEON_Complex64_t), tileA->n );
+ rc = cudaMemset2D( tileA->mat, sizeof(CHAMELEON_Complex64_t) * tileA->ld, 0,
+ sizeof(CHAMELEON_Complex64_t) * tileA->m, tileA->n );
assert( rc == CUBLAS_STATUS_SUCCESS );
(void)cl_arg;
diff --git a/runtime/starpu/codelets/codelet_zipiv_allreduce.c b/runtime/starpu/codelets/codelet_zipiv_allreduce.c
index 5e7254a28..a81f0d08e 100644
--- a/runtime/starpu/codelets/codelet_zipiv_allreduce.c
+++ b/runtime/starpu/codelets/codelet_zipiv_allreduce.c
@@ -54,7 +54,7 @@ static void cl_zipiv_allreduce_cpu_func( void *descr[], void *cl_arg )
( cppi_me->has_diag == -1 ) )
{
cblas_zcopy( clargs->n, nextpiv_src->diagrow, 1, nextpiv_me->diagrow, 1 );
- assert( cppi_src->arraysize == clargs->n * sizeof(CHAMELEON_Complex64_t) );
+ assert( cppi_src->arraysize == sizeof(CHAMELEON_Complex64_t) * clargs->n );
cppi_me->has_diag = 1;
}
diff --git a/runtime/starpu/interface/cppi_interface.c b/runtime/starpu/interface/cppi_interface.c
index d3d69856f..b340023e1 100644
--- a/runtime/starpu/interface/cppi_interface.c
+++ b/runtime/starpu/interface/cppi_interface.c
@@ -131,7 +131,7 @@ cppi_get_size(starpu_data_handle_t handle)
"Error. The given data is not a pivot interface." );
#endif
- size = cppi_interface->arraysize * 2 + 4 * sizeof(int);
+ size = cppi_interface->arraysize * 2 + sizeof(int) * 4;
return size;
}
@@ -248,7 +248,7 @@ cppi_peek_data( starpu_data_handle_t handle, unsigned node, void *ptr, size_t co
* received data has been registered. Thus, datatype was not existant and we
* need to unpack the data ourselves
*/
- STARPU_ASSERT( count == (size + 4 * sizeof(int)) );
+ STARPU_ASSERT( count == (size + sizeof(int) * 4) );
#else
diff --git a/testing/parameters.c b/testing/parameters.c
index 9607d83e9..092cf36d4 100644
--- a/testing/parameters.c
+++ b/testing/parameters.c
@@ -408,7 +408,7 @@ parameters_read_file( const char *filename )
}
len = 256;
- line_read = malloc( len * sizeof( char ) );
+ line_read = malloc( sizeof( char ) * len );
while ( getline( &line_read, &len, fp ) != -1 )
{
diff --git a/testing/testing_zcesca.c b/testing/testing_zcesca.c
index 11c13503f..251a06250 100644
--- a/testing/testing_zcesca.c
+++ b/testing/testing_zcesca.c
@@ -112,7 +112,7 @@ testing_zcesca_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Create the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA * N );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
diff --git a/testing/testing_zcheck_aux.c b/testing/testing_zcheck_aux.c
index 1c898a09b..3946e1365 100644
--- a/testing/testing_zcheck_aux.c
+++ b/testing/testing_zcheck_aux.c
@@ -83,7 +83,7 @@ int check_zmatrices_std( run_arg_list_t *args, cham_uplo_t uplo, int M, int N, C
double Anorm, Rnorm, result;
cham_fixdbl_t eps = testing_getaccuracy();
- double *work = (double *)malloc( (size_t) LDA*N*sizeof(double) );
+ double *work = (double *)malloc( sizeof(double) * LDA * N );
/* Computes the norms */
if ( uplo == ChamUpperLower ) {
@@ -163,8 +163,8 @@ int check_zmatrices( run_arg_list_t *args, cham_uplo_t uplo, CHAM_desc_t *descA,
CHAMELEON_Complex64_t *B = NULL;
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc((size_t)(LDA) * (size_t)(N) * sizeof(CHAMELEON_Complex64_t));
- B = (CHAMELEON_Complex64_t *)malloc((size_t)(LDB) * (size_t)(N) * sizeof(CHAMELEON_Complex64_t));
+ A = (CHAMELEON_Complex64_t *)malloc( (size_t)(LDA) * (size_t)(N) * sizeof(CHAMELEON_Complex64_t) );
+ B = (CHAMELEON_Complex64_t *)malloc( (size_t)(LDB) * (size_t)(N) * sizeof(CHAMELEON_Complex64_t) );
if ( (A == NULL) || (B == NULL) ) {
free( A );
free( B );
@@ -234,7 +234,7 @@ int check_znorm_std( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_norm
cham_diag_t diag, double norm_cham, int M, int N, CHAMELEON_Complex64_t *A, int LDA )
{
int info_solution = 0;
- double *work = (double*) malloc(chameleon_max(M, N)*sizeof(double));
+ double *work = (double*) malloc( sizeof(double) * chameleon_max(M, N) );
double norm_lapack;
double result;
cham_fixdbl_t eps = testing_getaccuracy();
@@ -341,7 +341,7 @@ int check_znorm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_normtype
int LDA = M;
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc(LDA*N*sizeof(CHAMELEON_Complex64_t));
+ A = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDA * N );
}
/* Converts the matrix to LAPACK layout in order to use the LAPACK norm function */
@@ -428,7 +428,7 @@ int check_zsum_std( run_arg_list_t *args, cham_uplo_t uplo, cham_trans_t trans,
}
cham_fixdbl_t eps = testing_getaccuracy();
- double *work = malloc(chameleon_max(M, N)* sizeof(double));
+ double *work = malloc( sizeof(double) * chameleon_max(M, N) );
/* Makes the sum with the core function */
if ( uplo == ChamUpperLower ) {
@@ -526,9 +526,9 @@ int check_zsum ( run_arg_list_t *args, cham_uplo_t uplo, cham_trans_t trans, CHA
cham_uplo_t uploA = uplo;
if ( rank == 0 ) {
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- Bref = malloc( (size_t) LDB*N* sizeof(CHAMELEON_Complex64_t) );
- Bcham = malloc( (size_t) LDB*N* sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA * An );
+ Bref = malloc( sizeof(CHAMELEON_Complex64_t) * LDB * N );
+ Bcham = malloc( sizeof(CHAMELEON_Complex64_t) * LDB * N );
}
if ( uplo != ChamUpperLower && trans != ChamNoTrans ) {
@@ -640,8 +640,8 @@ int check_zscale( run_arg_list_t *args, cham_uplo_t uplo, CHAMELEON_Complex64_t
CHAMELEON_Complex64_t *Ainit = NULL;
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc(LDA*N*sizeof(CHAMELEON_Complex64_t));
- Ainit = (CHAMELEON_Complex64_t *)malloc(LDA*N*sizeof(CHAMELEON_Complex64_t));
+ A = (CHAMELEON_Complex64_t *)malloc(sizeof( CHAMELEON_Complex64_t) * LDA * N );
+ Ainit = (CHAMELEON_Complex64_t *)malloc(sizeof( CHAMELEON_Complex64_t) * LDA * N );
}
/* Converts the matrix to LAPACK layout in order to scale with BLAS */
@@ -704,10 +704,10 @@ int check_zrankk_std( run_arg_list_t *args, int M, int N, int K, CHAMELEON_Compl
Anorm = LAPACKE_zlange( LAPACK_COL_MAJOR, 'F', M, N, A, LDA );
/* check rank of A using SVD, value K+1 of Sigma must be small enough */
- CHAMELEON_Complex64_t *U = malloc( (size_t) M * M * sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *VT = malloc( (size_t) N * N * sizeof(CHAMELEON_Complex64_t) );
- double *S = malloc( minMN * sizeof(double) );
- double *work = malloc( minMN * sizeof(double) );
+ CHAMELEON_Complex64_t *U = malloc( sizeof(CHAMELEON_Complex64_t) * M * M );
+ CHAMELEON_Complex64_t *VT = malloc( sizeof(CHAMELEON_Complex64_t) * N * N );
+ double *S = malloc( sizeof(double) * minMN );
+ double *work = malloc( sizeof(double) * minMN );
LAPACKE_zgesvd( LAPACK_COL_MAJOR, 'A', 'A', M, N, A, LDA, S, U, M, VT, N, work );
@@ -769,7 +769,7 @@ int check_zrankk( run_arg_list_t *args, int K, CHAM_desc_t *descA )
/* Converts the matrices to LAPACK layout in order to check values on the main process */
CHAMELEON_Complex64_t *A = NULL;
if ( rank == 0 ) {
- A = malloc( (size_t) M*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * M * N );
}
CHAMELEON_Desc2Lap( ChamUpperLower, descA, A, LDA );
diff --git a/testing/testing_zcheck_blas.c b/testing/testing_zcheck_blas.c
index 88b441a47..7c1dc5fd8 100644
--- a/testing/testing_zcheck_blas.c
+++ b/testing/testing_zcheck_blas.c
@@ -208,10 +208,10 @@ int check_zgemm( run_arg_list_t *args, cham_trans_t transA, cham_trans_t transB,
/* Creates the LAPACK version of the matrices */
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc(LDA*An*sizeof(CHAMELEON_Complex64_t));
- B = (CHAMELEON_Complex64_t *)malloc(LDB*Bn*sizeof(CHAMELEON_Complex64_t));
- Cref = (CHAMELEON_Complex64_t *)malloc(LDC*N *sizeof(CHAMELEON_Complex64_t));
- C = (CHAMELEON_Complex64_t *)malloc(LDC*N *sizeof(CHAMELEON_Complex64_t));
+ A = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDA * An );
+ B = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDB * Bn );
+ Cref = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDC * N );
+ C = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDC * N );
}
CHAMELEON_zDesc2Lap( ChamUpperLower, descA, A, LDA );
@@ -432,10 +432,10 @@ int check_zsymm( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_side_t s
int LDC = M;
if ( rank == 0 ) {
- A = ( CHAMELEON_Complex64_t * ) malloc( (size_t) LDA*An*sizeof( CHAMELEON_Complex64_t ) );
- B = ( CHAMELEON_Complex64_t * ) malloc( (size_t) LDB*N *sizeof( CHAMELEON_Complex64_t ) );
- Cref = ( CHAMELEON_Complex64_t * ) malloc( (size_t) LDC*N *sizeof( CHAMELEON_Complex64_t ) );
- C = ( CHAMELEON_Complex64_t * ) malloc( (size_t) LDC*N *sizeof( CHAMELEON_Complex64_t ) );
+ A = ( CHAMELEON_Complex64_t * ) malloc( sizeof( CHAMELEON_Complex64_t ) * LDA * An );
+ B = ( CHAMELEON_Complex64_t * ) malloc( sizeof( CHAMELEON_Complex64_t ) * LDB * N );
+ Cref = ( CHAMELEON_Complex64_t * ) malloc( sizeof( CHAMELEON_Complex64_t ) * LDC * N );
+ C = ( CHAMELEON_Complex64_t * ) malloc( sizeof( CHAMELEON_Complex64_t ) * LDC * N );
}
/* Creates the LAPACK version of the matrices */
@@ -691,12 +691,12 @@ int check_zsyrk( run_arg_list_t *args, cham_mtxtype_t matrix_type, cham_uplo_t u
LDC = N;
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc( (size_t) LDA * An * sizeof(CHAMELEON_Complex64_t) );
+ A = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDA * An );
if ( descB != NULL ) {
- B = (CHAMELEON_Complex64_t *)malloc( (size_t) LDB * Bn * sizeof(CHAMELEON_Complex64_t) );
+ B = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDB * Bn );
}
- Cref = (CHAMELEON_Complex64_t *)malloc( (size_t) LDC * N * sizeof(CHAMELEON_Complex64_t) );
- C = (CHAMELEON_Complex64_t *)malloc( (size_t) LDC * N * sizeof(CHAMELEON_Complex64_t) );
+ Cref = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDC * N );
+ C = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDC * N );
}
/* Creates the LAPACK version of the matrices */
@@ -899,9 +899,9 @@ int check_ztrmm( run_arg_list_t *args, int check_func, cham_side_t side, cham_up
int LDB = M;
if ( rank == 0 ) {
- A = (CHAMELEON_Complex64_t *)malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- Bref = (CHAMELEON_Complex64_t *)malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
- B = (CHAMELEON_Complex64_t *)malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ A = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDA * An );
+ Bref = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDB * N );
+ B = (CHAMELEON_Complex64_t *)malloc( sizeof(CHAMELEON_Complex64_t) * LDB * N );
}
/* Creates the LAPACK version of the matrices */
diff --git a/testing/testing_zcheck_svd.c b/testing/testing_zcheck_svd.c
index cfcfece9f..b30b98b63 100644
--- a/testing/testing_zcheck_svd.c
+++ b/testing/testing_zcheck_svd.c
@@ -236,8 +236,8 @@ int check_zgesvd( run_arg_list_t *args, cham_job_t jobu, cham_job_t jobvt, CHAM_
int LDA = descA->lm;
if ( rank == 0 ) {
- Ainit = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ Ainit = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
}
CHAMELEON_zDesc2Lap( ChamUpperLower, descAinit, Ainit, LDA );
diff --git a/testing/testing_zgeadd.c b/testing/testing_zgeadd.c
index 244b097ff..bf094e7d3 100644
--- a/testing/testing_zgeadd.c
+++ b/testing/testing_zgeadd.c
@@ -147,8 +147,8 @@ testing_zgeadd_std( run_arg_list_t *args, int check )
An = (trans == ChamNoTrans)? N : M;
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -162,7 +162,7 @@ testing_zgeadd_std( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
- CHAMELEON_Complex64_t *B0 = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *B0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
CHAMELEON_zplrnt( M, N, B0, LDB, seedB );
hres += check_zsum_std( args, ChamUpperLower, trans, M, N, alpha, A, LDA, beta, B0, B, LDB );
diff --git a/testing/testing_zgelqf.c b/testing/testing_zgelqf.c
index 71df7316e..d52d74591 100644
--- a/testing/testing_zgelqf.c
+++ b/testing/testing_zgelqf.c
@@ -135,7 +135,7 @@ testing_zgelqf_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -149,8 +149,8 @@ testing_zgelqf_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) N*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * N*N );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
diff --git a/testing/testing_zgelqf_hqr.c b/testing/testing_zgelqf_hqr.c
index 59fedc2d4..1a958340c 100644
--- a/testing/testing_zgelqf_hqr.c
+++ b/testing/testing_zgelqf_hqr.c
@@ -144,7 +144,7 @@ testing_zgelqf_hqr_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_INNER_BLOCK_SIZE, ib );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -167,8 +167,8 @@ testing_zgelqf_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) N*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * N*N );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
diff --git a/testing/testing_zgels.c b/testing/testing_zgels.c
index 09f5985ab..72d43c18e 100644
--- a/testing/testing_zgels.c
+++ b/testing/testing_zgels.c
@@ -181,8 +181,8 @@ testing_zgels_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -198,8 +198,8 @@ testing_zgels_std( run_arg_list_t *args, int check )
if ( check ) {
CHAMELEON_Complex64_t *A0, *B;
- A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
CHAMELEON_zplrnt( maxMN, NRHS, B, LDB, seedB );
diff --git a/testing/testing_zgels_hqr.c b/testing/testing_zgels_hqr.c
index 3ce803323..a9bf0aa6f 100644
--- a/testing/testing_zgels_hqr.c
+++ b/testing/testing_zgels_hqr.c
@@ -184,8 +184,8 @@ testing_zgels_hqr_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_INNER_BLOCK_SIZE, ib );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -211,8 +211,8 @@ testing_zgels_hqr_std( run_arg_list_t *args, int check )
if ( check ) {
CHAMELEON_Complex64_t *A0, *B;
- A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
CHAMELEON_zplrnt( maxMN, NRHS, B, LDB, seedB );
diff --git a/testing/testing_zgemm.c b/testing/testing_zgemm.c
index fa31d578d..6f96f3f01 100644
--- a/testing/testing_zgemm.c
+++ b/testing/testing_zgemm.c
@@ -184,9 +184,9 @@ testing_zgemm_std( run_arg_list_t *args, int check )
}
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*Bn );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fill the matrices with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -222,7 +222,7 @@ testing_zgemm_std( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplrnt( M, N, Cinit, LDC, seedC );
hres += check_zgemm_std( args, transA, transB, alpha, M, N, K, A, LDA, B, LDB, beta, Cinit, C, LDC );
diff --git a/testing/testing_zgenm2.c b/testing/testing_zgenm2.c
index 0751ca971..bc8f3b27f 100644
--- a/testing/testing_zgenm2.c
+++ b/testing/testing_zgenm2.c
@@ -69,7 +69,7 @@ testing_zgenm2_desc( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Generate the diagonal of eigen/singular values */
- D = malloc( minMN * sizeof(double) );
+ D = malloc( sizeof(double) * minMN );
#if !defined(CHAMELEON_SIMULATION)
hres = CORE_dlatm1( mode, cond, 0, ChamDistUniform, seedA, D, minMN );
if ( hres != 0 ) {
@@ -152,7 +152,7 @@ testing_zgenm2_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Generate the diagonal of eigen/singular values */
- D = malloc( minMN * sizeof(double) );
+ D = malloc( sizeof(double) * minMN );
#if !defined(CHAMELEON_SIMULATION)
hres = CORE_dlatm1( mode, cond, 0, ChamDistUniform, seedA, D, minMN );
if ( hres != 0 ) {
@@ -168,7 +168,7 @@ testing_zgenm2_std( run_arg_list_t *args, int check )
#endif
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
hres = CHAMELEON_zlatms( M, N, ChamDistUniform, seedA, ChamNonsymPosv, D, 0, cond, 0., A, LDA );
diff --git a/testing/testing_zgepdf_qdwh.c b/testing/testing_zgepdf_qdwh.c
index d6896c5e3..b3c153edb 100644
--- a/testing/testing_zgepdf_qdwh.c
+++ b/testing/testing_zgepdf_qdwh.c
@@ -162,8 +162,8 @@ testing_zgepdf_qdwh_std( run_arg_list_t *args, int check )
}
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- H = malloc( (size_t) LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ H = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fills the matrix with random values */
hres = CHAMELEON_zlatms( M, N, ChamDistUniform, seedA, ChamNonsymPosv, NULL, mode, cond, 1., A, LDA );
@@ -178,7 +178,7 @@ testing_zgepdf_qdwh_std( run_arg_list_t *args, int check )
* with the call to CHAMELEON_zgepdf_qdwh).
*/
if ( check ) {
- A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zlacpy( ChamUpperLower, M, N, A, LDA, A0, LDA );
}
diff --git a/testing/testing_zgeqrf.c b/testing/testing_zgeqrf.c
index 53c593ad4..a012eb8aa 100644
--- a/testing/testing_zgeqrf.c
+++ b/testing/testing_zgeqrf.c
@@ -135,7 +135,7 @@ testing_zgeqrf_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -149,8 +149,8 @@ testing_zgeqrf_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) M*M*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * M*M );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
diff --git a/testing/testing_zgeqrf_hqr.c b/testing/testing_zgeqrf_hqr.c
index 42a4f209d..92f20f724 100644
--- a/testing/testing_zgeqrf_hqr.c
+++ b/testing/testing_zgeqrf_hqr.c
@@ -144,7 +144,7 @@ testing_zgeqrf_hqr_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_INNER_BLOCK_SIZE, ib );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, N, &descTT, P, Q );
@@ -167,8 +167,8 @@ testing_zgeqrf_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) M*M*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * M*M );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
diff --git a/testing/testing_zgesv_nopiv.c b/testing/testing_zgesv_nopiv.c
index 46e946d9d..2c1844761 100644
--- a/testing/testing_zgesv_nopiv.c
+++ b/testing/testing_zgesv_nopiv.c
@@ -124,8 +124,8 @@ testing_zgesv_nopiv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplgtr( 0, ChamUpper, N, N, A, LDA, seedA );
@@ -142,8 +142,8 @@ testing_zgesv_nopiv_std( run_arg_list_t *args, int check )
if ( check ) {
CHAMELEON_Complex64_t *A0, *B;
- A0 = malloc( (size_t) LDA*N *sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplgtr( 0, ChamUpper, N, N, A0, LDA, seedA );
CHAMELEON_zplgtr( bump, ChamLower, N, N, A0, LDA, seedA+1 );
CHAMELEON_zplrnt( N, NRHS, B, LDB, seedB );
diff --git a/testing/testing_zgesvd.c b/testing/testing_zgesvd.c
index ae5602c18..94b837146 100644
--- a/testing/testing_zgesvd.c
+++ b/testing/testing_zgesvd.c
@@ -107,7 +107,7 @@ testing_zgesvd_desc( run_arg_list_t *args, int check )
if ( (jobu == ChamAllVec) || (jobu == ChamSVec) ) {
Un = ( jobu == ChamSVec ) ? K : M;
- U = malloc( (size_t) LDU*Un*sizeof(CHAMELEON_Complex64_t) );
+ U = malloc( sizeof(CHAMELEON_Complex64_t) * LDU*Un );
}
else {
U = NULL;
@@ -115,15 +115,15 @@ testing_zgesvd_desc( run_arg_list_t *args, int check )
if ( (jobvt == ChamAllVec) || (jobvt == ChamSVec) ) {
LDVt = ( jobvt == ChamSVec ) ? K : N;
- Vt = malloc( (size_t) LDVt*N*sizeof(CHAMELEON_Complex64_t) );
+ Vt = malloc( sizeof(CHAMELEON_Complex64_t) * LDVt*N );
}
else {
Vt = NULL;
}
/* Generate the diagonal of eigen/singular values */
- D = malloc( K*sizeof(double) );
- S = malloc( K*sizeof(double) );
+ D = malloc( sizeof(double) * K );
+ S = malloc( sizeof(double) * K );
/* Fills the matrix with random values */
hres = CHAMELEON_zlatms_Tile( ChamDistUniform, seedA, ChamNonsymPosv, D, mode, cond, 1., descA );
@@ -212,12 +212,12 @@ testing_zgesvd_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgesvd( M, N, &descT, 1, 1 );
if ( (jobu == ChamAllVec) || (jobu == ChamSVec) ) {
Un = ( jobu == ChamSVec ) ? K : M;
- U = malloc( (size_t) LDU*Un*sizeof(CHAMELEON_Complex64_t) );
+ U = malloc( sizeof(CHAMELEON_Complex64_t) * LDU*Un );
}
else {
U = NULL;
@@ -225,15 +225,15 @@ testing_zgesvd_std( run_arg_list_t *args, int check )
if ( (jobvt == ChamAllVec) || (jobvt == ChamSVec) ) {
LDVt = ( jobvt == ChamSVec ) ? K : N;
- Vt = malloc( (size_t) LDVt*N*sizeof(CHAMELEON_Complex64_t) );
+ Vt = malloc( sizeof(CHAMELEON_Complex64_t) * LDVt*N );
}
else {
Vt = NULL;
}
/* Generate the diagonal of eigen/singular values */
- D = malloc( K*sizeof(double) );
- S = malloc( K*sizeof(double) );
+ D = malloc( sizeof(double) * K );
+ S = malloc( sizeof(double) * K );
/* Fills the matrix with random values */
hres = CHAMELEON_zlatms( M, N, ChamDistUniform, seedA, ChamNonsymPosv, D, mode, cond, 1., A, LDA );
@@ -250,7 +250,7 @@ testing_zgesvd_std( run_arg_list_t *args, int check )
* with the call to CHAMELEON_zgepdf_qdwh).
*/
if ( check ) {
- A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zlacpy( ChamUpperLower, M, N, A, LDA, A0, LDA );
}
diff --git a/testing/testing_zgetrf.c b/testing/testing_zgetrf.c
index 310e5f5bf..a1cbf529d 100644
--- a/testing/testing_zgetrf.c
+++ b/testing/testing_zgetrf.c
@@ -128,7 +128,7 @@ testing_zgetrf_desc( run_arg_list_t *args, int check )
if ( CHAMELEON_Comm_rank() == 0 ) {
int *ipiv;
- ipiv = malloc( minMN * sizeof(int) );
+ ipiv = malloc( sizeof(int) * minMN );
CHAMELEON_Ipiv_Gather( descIPIV, ipiv, 0 );
LAPACKE_zlaswp( LAPACK_COL_MAJOR, N, descA0c->mat, M, 1, minMN, ipiv, 1 );
free( ipiv );
@@ -180,8 +180,8 @@ testing_zgetrf_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- IPIV = malloc( minMN * sizeof(int) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ IPIV = malloc( sizeof(int) * minMN );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
@@ -216,7 +216,7 @@ testing_zgetrf_std( run_arg_list_t *args, int check )
#if !defined(CHAMELEON_SIMULATION)
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( M, N, A0, LDA, seedA );
/* Compute the permutation of A0: P * A0 */
diff --git a/testing/testing_zgetrf_nopiv.c b/testing/testing_zgetrf_nopiv.c
index 51711401d..b300c124a 100644
--- a/testing/testing_zgetrf_nopiv.c
+++ b/testing/testing_zgetrf_nopiv.c
@@ -100,7 +100,7 @@ testing_zgetrf_nopiv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplgtr( 0, ChamUpper, M, N, A, LDA, seedA );
@@ -114,7 +114,7 @@ testing_zgetrf_nopiv_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplgtr( 0, ChamUpper, M, N, A0, LDA, seedA );
CHAMELEON_zplgtr( bump, ChamLower, M, N, A0, LDA, seedA+1 );
diff --git a/testing/testing_zgetrs_nopiv.c b/testing/testing_zgetrs_nopiv.c
index f75048d01..87ec30c43 100644
--- a/testing/testing_zgetrs_nopiv.c
+++ b/testing/testing_zgetrs_nopiv.c
@@ -116,8 +116,8 @@ testing_zgetrs_nopiv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplgtr( 0, ChamUpper, N, N, A, LDA, seedA );
@@ -135,8 +135,8 @@ testing_zgetrs_nopiv_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ CHAMELEON_Complex64_t *B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplgtr( 0, ChamUpper, N, N, A0, LDA, seedA );
CHAMELEON_zplgtr( bump, ChamLower, N, N, A0, LDA, seedA+1 );
diff --git a/testing/testing_zgram.c b/testing/testing_zgram.c
index c974d5523..ea36cb1ba 100644
--- a/testing/testing_zgram.c
+++ b/testing/testing_zgram.c
@@ -111,7 +111,7 @@ testing_zgram_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Create the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fill the matrix with random values */
CHAMELEON_zplghe( (double)N, uplo, N,A, LDA, seedA );
diff --git a/testing/testing_zhemm.c b/testing/testing_zhemm.c
index b17d9ea27..2ff302258 100644
--- a/testing/testing_zhemm.c
+++ b/testing/testing_zhemm.c
@@ -163,9 +163,9 @@ testing_zhemm_std( run_arg_list_t *args, int check )
An = ( side == ChamLeft ) ? M : N;
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fills the matrix with random values */
CHAMELEON_zplghe( bump, uplo, An, A, LDA, seedA );
@@ -201,7 +201,7 @@ testing_zhemm_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplrnt( M, N, Cinit, LDC, seedC );
hres += check_zsymm_std( args, ChamHermitian, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
diff --git a/testing/testing_zher2k.c b/testing/testing_zher2k.c
index 5a4d1433f..2408c59a9 100644
--- a/testing/testing_zher2k.c
+++ b/testing/testing_zher2k.c
@@ -167,9 +167,9 @@ testing_zher2k_std( run_arg_list_t *args, int check )
}
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*Bn );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -205,7 +205,7 @@ testing_zher2k_std( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
diff --git a/testing/testing_zherk.c b/testing/testing_zherk.c
index dd11d04a3..09085a385 100644
--- a/testing/testing_zherk.c
+++ b/testing/testing_zherk.c
@@ -156,8 +156,8 @@ testing_zherk_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -192,7 +192,7 @@ testing_zherk_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplghe( bump, uplo, N, Cinit, LDC, seedC );
hres += check_zsyrk_std( args, ChamHermitian, uplo, trans, N, K, alpha, A, LDA, NULL, LDA, beta, Cinit, C, LDC );
diff --git a/testing/testing_zlacpy.c b/testing/testing_zlacpy.c
index 6d174ffb1..a6d4d7577 100644
--- a/testing/testing_zlacpy.c
+++ b/testing/testing_zlacpy.c
@@ -138,8 +138,8 @@ testing_zlacpy_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates two different matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fills each matrix with different random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
diff --git a/testing/testing_zlange.c b/testing/testing_zlange.c
index f7dcb8b5e..1f636d91a 100644
--- a/testing/testing_zlange.c
+++ b/testing/testing_zlange.c
@@ -136,7 +136,7 @@ testing_zlange_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
diff --git a/testing/testing_zlanhe.c b/testing/testing_zlanhe.c
index ceeceba02..c39a70218 100644
--- a/testing/testing_zlanhe.c
+++ b/testing/testing_zlanhe.c
@@ -137,7 +137,7 @@ testing_zlanhe_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplghe( bump, uplo, N, A, LDA, seedA );
diff --git a/testing/testing_zlansy.c b/testing/testing_zlansy.c
index 5cb7507ac..10ed12f05 100644
--- a/testing/testing_zlansy.c
+++ b/testing/testing_zlansy.c
@@ -137,7 +137,7 @@ testing_zlansy_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplgsy( bump, uplo, N, A, LDA, seedA );
diff --git a/testing/testing_zlantr.c b/testing/testing_zlantr.c
index 71b8d6dd5..f84fb6b00 100644
--- a/testing/testing_zlantr.c
+++ b/testing/testing_zlantr.c
@@ -160,7 +160,7 @@ testing_zlantr_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
diff --git a/testing/testing_zlascal.c b/testing/testing_zlascal.c
index 479a91f32..816d654b9 100644
--- a/testing/testing_zlascal.c
+++ b/testing/testing_zlascal.c
@@ -131,7 +131,7 @@ testing_zlascal_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( M, N, A, LDA, seedA );
@@ -144,7 +144,7 @@ testing_zlascal_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
- CHAMELEON_Complex64_t *Ainit = malloc ( LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *Ainit = malloc( sizeof(CHAMELEON_Complex64_t) * LDA * N );
CHAMELEON_zplrnt( M, N, Ainit, LDA, seedA );
hres += check_zscale_std( args, uplo, M, N, alpha, Ainit, A, LDA );
diff --git a/testing/testing_zlauum.c b/testing/testing_zlauum.c
index 2899c9dee..7623d0f24 100644
--- a/testing/testing_zlauum.c
+++ b/testing/testing_zlauum.c
@@ -106,7 +106,7 @@ testing_zlauum_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Initialises the matrices with the same values */
CHAMELEON_zplghe( 0., uplo, N, A, LDA, seedA );
@@ -133,7 +133,7 @@ testing_zlauum_std( run_arg_list_t *args, int check )
testing_stop( &test_data, flops_zlauum( N ) );
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplghe( 0., uplo, N, A0, LDA, seedA );
hres += check_zlauum_std( args, uplo, N, A0, A, LDA );
diff --git a/testing/testing_zplrnk.c b/testing/testing_zplrnk.c
index 19d47f23f..f18fbada5 100644
--- a/testing/testing_zplrnk.c
+++ b/testing/testing_zplrnk.c
@@ -92,7 +92,7 @@ testing_zplrnk_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrix */
- C = malloc ( LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC * N );
/* Calculates the random rank-k matrix */
testing_start( &test_data );
diff --git a/testing/testing_zpoinv.c b/testing/testing_zpoinv.c
index d6f35a056..3e33f0f0b 100644
--- a/testing/testing_zpoinv.c
+++ b/testing/testing_zpoinv.c
@@ -109,7 +109,7 @@ testing_zpoinv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Create the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Initialise the matrix with the random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -129,7 +129,7 @@ testing_zpoinv_std( run_arg_list_t *args, int check )
/* Check the inverse */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA * N * sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA * N );
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
hres += check_ztrtri_std( args, ChamHermitian, uplo, ChamNonUnit, N, A0, A, LDA );
diff --git a/testing/testing_zposv.c b/testing/testing_zposv.c
index 368821eed..e07c42ab9 100644
--- a/testing/testing_zposv.c
+++ b/testing/testing_zposv.c
@@ -131,8 +131,8 @@ testing_zposv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N *sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -167,8 +167,8 @@ testing_zposv_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ CHAMELEON_Complex64_t *B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Check the factorization */
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
diff --git a/testing/testing_zpotrf.c b/testing/testing_zpotrf.c
index cf62105cc..b2fc5e064 100644
--- a/testing/testing_zpotrf.c
+++ b/testing/testing_zpotrf.c
@@ -103,7 +103,7 @@ testing_zpotrf_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -137,7 +137,7 @@ testing_zpotrf_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
hres += check_zxxtrf_std( args, ChamHermitian, uplo, N, N, A0, A, LDA );
diff --git a/testing/testing_zpotri.c b/testing/testing_zpotri.c
index 6b3c2fd24..33a06056f 100644
--- a/testing/testing_zpotri.c
+++ b/testing/testing_zpotri.c
@@ -106,7 +106,7 @@ testing_zpotri_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Create the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Initialise the matrix with the random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -147,7 +147,7 @@ testing_zpotri_std( run_arg_list_t *args, int check )
/* Check the inverse */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
hres += check_ztrtri_std( args, ChamHermitian, uplo, ChamNonUnit, N, A0, A, LDA );
diff --git a/testing/testing_zpotrs.c b/testing/testing_zpotrs.c
index 687a3d7c7..fb0be7a37 100644
--- a/testing/testing_zpotrs.c
+++ b/testing/testing_zpotrs.c
@@ -121,8 +121,8 @@ testing_zpotrs_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -164,8 +164,8 @@ testing_zpotrs_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ CHAMELEON_Complex64_t *B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplghe( (double)N, ChamUpperLower, N, A0, LDA, seedA );
CHAMELEON_zplrnt( N, NRHS, B, LDB, seedB );
diff --git a/testing/testing_zsymm.c b/testing/testing_zsymm.c
index 9165b869e..af93617e2 100644
--- a/testing/testing_zsymm.c
+++ b/testing/testing_zsymm.c
@@ -163,9 +163,9 @@ testing_zsymm_std( run_arg_list_t *args, int check )
An = ( side == ChamLeft ) ? M : N;
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fills the matrix with random values */
CHAMELEON_zplgsy( bump, uplo, An, A, LDA, seedA );
@@ -201,7 +201,7 @@ testing_zsymm_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplrnt( M, N, Cinit, LDC, seedC );
hres += check_zsymm_std( args, ChamSymmetric, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
diff --git a/testing/testing_zsyr2k.c b/testing/testing_zsyr2k.c
index 08e7985a8..df150ca1c 100644
--- a/testing/testing_zsyr2k.c
+++ b/testing/testing_zsyr2k.c
@@ -167,9 +167,9 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
}
/* Create the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*Bn*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*Bn );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fill the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -205,7 +205,7 @@ testing_zsyr2k_std( run_arg_list_t *args, int check )
/* Check the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, LDA, B, LDB, beta, Cinit, C, LDC );
diff --git a/testing/testing_zsyrk.c b/testing/testing_zsyrk.c
index d182060c8..2d1657fdc 100644
--- a/testing/testing_zsyrk.c
+++ b/testing/testing_zsyrk.c
@@ -155,8 +155,8 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( Am, An, A, LDA, seedA );
@@ -191,7 +191,7 @@ testing_zsyrk_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Cinit;
- Cinit = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ Cinit = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_zplgsy( bump, uplo, N, Cinit, LDC, seedC );
hres += check_zsyrk_std( args, ChamSymmetric, uplo, trans, N, K, alpha, A, LDA, NULL, LDA, beta, Cinit, C, LDC );
diff --git a/testing/testing_zsysv.c b/testing/testing_zsysv.c
index 35ef84ba0..ca50dc598 100644
--- a/testing/testing_zsysv.c
+++ b/testing/testing_zsysv.c
@@ -123,8 +123,8 @@ testing_zsysv_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplgsy( (double)N, uplo, N, A, LDA, seedA );
@@ -141,13 +141,13 @@ testing_zsysv_std( run_arg_list_t *args, int check )
CHAMELEON_Complex64_t *A0, *B;
/* Check the factorization */
- A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplgsy( (double)N, uplo, N, A0, LDA, seedA );
hres += check_zxxtrf_std( args, ChamSymmetric, uplo, N, N, A0, A, LDA );
/* Check the solve */
- B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplrnt( N, NRHS, B, LDB, seedB );
CHAMELEON_zplgsy( (double)N, uplo, N, A0, LDA, seedA );
diff --git a/testing/testing_zsytrf.c b/testing/testing_zsytrf.c
index 2d42111fe..d75b0a7fe 100644
--- a/testing/testing_zsytrf.c
+++ b/testing/testing_zsytrf.c
@@ -94,7 +94,7 @@ testing_zsytrf_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Fills the matrix with random values */
CHAMELEON_zplgsy( (double)N, uplo, N, A, LDA, seedA );
@@ -107,7 +107,7 @@ testing_zsytrf_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplgsy( (double)N, uplo, N, A0, LDA, seedA );
hres += check_zxxtrf_std( args, ChamSymmetric, uplo, N, N, A0, A, LDA );
diff --git a/testing/testing_zsytrs.c b/testing/testing_zsytrs.c
index fb7fd0d20..c420b02d7 100644
--- a/testing/testing_zsytrs.c
+++ b/testing/testing_zsytrs.c
@@ -113,8 +113,8 @@ testing_zsytrs_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- X = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ X = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
/* Fills the matrix with random values */
CHAMELEON_zplgsy( (double)N, uplo, N, A, LDA, seedA );
@@ -131,8 +131,8 @@ testing_zsytrs_std( run_arg_list_t *args, int check )
/* Checks the factorisation and residue */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N* sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *B = malloc( (size_t) LDB*NRHS*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ CHAMELEON_Complex64_t *B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*NRHS );
CHAMELEON_zplgsy( (double)N, uplo, N, A0, LDA, seedA );
CHAMELEON_zplrnt( N, NRHS, B, LDB, seedB );
diff --git a/testing/testing_ztradd.c b/testing/testing_ztradd.c
index a3412017b..158f6dfc3 100644
--- a/testing/testing_ztradd.c
+++ b/testing/testing_ztradd.c
@@ -193,8 +193,8 @@ testing_ztradd_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N* sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fills the matrix with random values */
switch ( uplo ) {
@@ -218,7 +218,7 @@ testing_ztradd_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
- CHAMELEON_Complex64_t *B0 = malloc( (size_t) LDB*N* sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *B0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
if ( uplo == ChamUpperLower ) {
CHAMELEON_zplrnt( M, N, B0, LDB, seedB );
diff --git a/testing/testing_ztrmm.c b/testing/testing_ztrmm.c
index d9ecddad6..9c2b460ee 100644
--- a/testing/testing_ztrmm.c
+++ b/testing/testing_ztrmm.c
@@ -140,8 +140,8 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
An = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fills the matrix with random values */
CHAMELEON_zplrnt( An, An, A, LDA, seedA );
@@ -177,7 +177,7 @@ testing_ztrmm_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Binit;
- Binit = malloc( (size_t) LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ Binit = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
CHAMELEON_zplrnt( M, N, Binit, LDB, seedB );
hres += check_ztrmm_std( args, CHECK_TRMM, side, uplo, trans, diag, M, N, alpha, A, LDA, B, Binit, LDB );
diff --git a/testing/testing_ztrsm.c b/testing/testing_ztrsm.c
index c87f6e9ee..72c63085d 100644
--- a/testing/testing_ztrsm.c
+++ b/testing/testing_ztrsm.c
@@ -132,8 +132,8 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- B = malloc( (size_t) LDB*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ B = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
/* Fills the matrix with random values */
/* We bump a little bit the diagonal to make it stable */
@@ -170,7 +170,7 @@ testing_ztrsm_std( run_arg_list_t *args, int check )
/* Checks the solution */
if ( check ) {
CHAMELEON_Complex64_t *Binit;
- Binit = malloc( (size_t) LDB*N*sizeof(CHAMELEON_Complex64_t) );
+ Binit = malloc( sizeof(CHAMELEON_Complex64_t) * LDB*N );
CHAMELEON_zplrnt( M, N, Binit, LDB, seedB );
hres += check_ztrmm_std( args, CHECK_TRSM, side, uplo, trans, diag, M, N, alpha, A, LDA, B, Binit, LDB );
diff --git a/testing/testing_ztrtri.c b/testing/testing_ztrtri.c
index 6bf5cec0d..e624b269e 100644
--- a/testing/testing_ztrtri.c
+++ b/testing/testing_ztrtri.c
@@ -102,7 +102,7 @@ testing_ztrtri_std( run_arg_list_t *args, int check )
CHAMELEON_Set( CHAMELEON_TILE_SIZE, nb );
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
/* Initialises the matrices with the same values */
CHAMELEON_zplghe( (double)N, uplo, N, A, LDA, seedA );
@@ -130,7 +130,7 @@ testing_ztrtri_std( run_arg_list_t *args, int check )
/* Checks the inverse */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplghe( (double)N, uplo, N, A0, LDA, seedA );
hres += check_ztrtri_std( args, ChamTriangular, uplo, diag, N, A0, A, LDA );
diff --git a/testing/testing_zunglq.c b/testing/testing_zunglq.c
index b38d0374f..adbb2d113 100644
--- a/testing/testing_zunglq.c
+++ b/testing/testing_zunglq.c
@@ -165,8 +165,8 @@ testing_zunglq_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- Qlap = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descT, P, Q );
/* Fills the matrix with random values */
@@ -187,7 +187,7 @@ testing_zunglq_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( K, N, A0, LDA, seedA );
hres += check_zortho_std( args, M, N, Qlap, LDA );
diff --git a/testing/testing_zunglq_hqr.c b/testing/testing_zunglq_hqr.c
index dcf4f891d..a4efca0f4 100644
--- a/testing/testing_zunglq_hqr.c
+++ b/testing/testing_zunglq_hqr.c
@@ -175,8 +175,8 @@ testing_zunglq_hqr_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
- Qlap = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
+ Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, N, &descTT, P, Q );
@@ -208,7 +208,7 @@ testing_zunglq_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_zplrnt( K, N, A0, LDA, seedA );
hres += check_zortho_std( args, M, N, Qlap, LDA );
diff --git a/testing/testing_zungqr.c b/testing/testing_zungqr.c
index 1ec9b5630..59048da7d 100644
--- a/testing/testing_zungqr.c
+++ b/testing/testing_zungqr.c
@@ -165,8 +165,8 @@ testing_zungqr_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
- Qlap = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
+ Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descT, P, Q );
/* Fills the matrix with random values */
@@ -187,7 +187,7 @@ testing_zungqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
CHAMELEON_zplrnt( M, K, A0, LDA, seedA );
hres += check_zortho_std( args, M, N, Qlap, LDA );
diff --git a/testing/testing_zungqr_hqr.c b/testing/testing_zungqr_hqr.c
index bd37dfb94..38ad7791f 100644
--- a/testing/testing_zungqr_hqr.c
+++ b/testing/testing_zungqr_hqr.c
@@ -175,8 +175,8 @@ testing_zungqr_hqr_std( run_arg_list_t *args, int check )
}
/* Creates the matrices */
- A = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
- Qlap = malloc( (size_t) LDA*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
+ Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*N );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( M, K, &descTT, P, Q );
@@ -208,7 +208,7 @@ testing_zungqr_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *A0 = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *A0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
CHAMELEON_zplrnt( M, K, A0, LDA, seedA );
hres += check_zortho_std( args, M, N, Qlap, LDA );
diff --git a/testing/testing_zunmlq.c b/testing/testing_zunmlq.c
index 5dc1b41d4..354c0c3d1 100644
--- a/testing/testing_zunmlq.c
+++ b/testing/testing_zunmlq.c
@@ -162,8 +162,8 @@ testing_zunmlq_std( run_arg_list_t *args, int check )
An = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descT, P, Q );
/* Fills the matrix with random values */
@@ -181,8 +181,8 @@ testing_zunmlq_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *C0 = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) An*An*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *C0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * An*An );
CHAMELEON_zplrnt( M, N, C0, LDC, seedC );
CHAMELEON_zunglq( An, An, K, A, LDA, descT, Qlap, An );
diff --git a/testing/testing_zunmlq_hqr.c b/testing/testing_zunmlq_hqr.c
index 7399d260d..6278fd53f 100644
--- a/testing/testing_zunmlq_hqr.c
+++ b/testing/testing_zunmlq_hqr.c
@@ -170,8 +170,8 @@ testing_zunmlq_hqr_std( run_arg_list_t *args, int check )
An = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- A = malloc( (size_t) LDA*An*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N *sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*An );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( K, An, &descTT, P, Q );
@@ -198,8 +198,8 @@ testing_zunmlq_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *C0 = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) An*An*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *C0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * An*An );
CHAMELEON_zplrnt( M, N, C0, LDC, seedC );
CHAMELEON_zunglq_param( &qrtree, An, An, K, A, LDA, descTS, descTT, Qlap, An );
diff --git a/testing/testing_zunmqr.c b/testing/testing_zunmqr.c
index 4217e5919..c1a28209a 100644
--- a/testing/testing_zunmqr.c
+++ b/testing/testing_zunmqr.c
@@ -162,8 +162,8 @@ testing_zunmqr_std( run_arg_list_t *args, int check )
Am = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- A = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descT, P, Q );
/* Fills the matrix with random values */
@@ -181,8 +181,8 @@ testing_zunmqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *C0 = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) Am*Am*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *C0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * Am*Am );
CHAMELEON_zplrnt( M, N, C0, LDC, seedC );
CHAMELEON_zungqr( Am, Am, K, A, LDA, descT, Qlap, Am );
diff --git a/testing/testing_zunmqr_hqr.c b/testing/testing_zunmqr_hqr.c
index 3196b21a4..450f7c4ea 100644
--- a/testing/testing_zunmqr_hqr.c
+++ b/testing/testing_zunmqr_hqr.c
@@ -170,8 +170,8 @@ testing_zunmqr_hqr_std( run_arg_list_t *args, int check )
Am = ( side == ChamLeft ) ? M : N;
/* Creates the matrices */
- A = malloc( (size_t) LDA*K*sizeof(CHAMELEON_Complex64_t) );
- C = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
+ A = malloc( sizeof(CHAMELEON_Complex64_t) * LDA*K );
+ C = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descTS, P, Q );
CHAMELEON_Alloc_Workspace_zgels( Am, K, &descTT, P, Q );
@@ -198,8 +198,8 @@ testing_zunmqr_hqr_std( run_arg_list_t *args, int check )
/* Checks the factorisation and orthogonality */
if ( check ) {
- CHAMELEON_Complex64_t *C0 = malloc( (size_t) LDC*N*sizeof(CHAMELEON_Complex64_t) );
- CHAMELEON_Complex64_t *Qlap = malloc( (size_t) Am*Am*sizeof(CHAMELEON_Complex64_t) );
+ CHAMELEON_Complex64_t *C0 = malloc( sizeof(CHAMELEON_Complex64_t) * LDC*N );
+ CHAMELEON_Complex64_t *Qlap = malloc( sizeof(CHAMELEON_Complex64_t) * Am*Am );
CHAMELEON_zplrnt( M, N, C0, LDC, seedC );
CHAMELEON_zungqr_param( &qrtree, Am, Am, K, A, LDA, descTS, descTT, Qlap, Am );
--
GitLab