diff --git a/compute/pzlatms.c b/compute/pzlatms.c
index 7e6fd24e3eb7f053ef7a6efe0de702316773b394..a672d026ab70cdf08833f177bb90b23954a8f5d0 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 97e7c8bdccb2f45b323717391d7ccf7c892e5a06..610ab8d381d42c15fba6e7669ff83625f62435cc 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 9528a28d7f077b9a0622020b2816320f6b7a716a..bcac0fa9cc72e2aebeb672242227f7a516120504 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 510346b7a122d3754024b1cada67bd2094fbb250..6f2c4fc065f12dcaa96d269296e708563ed8cef6 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/auxiliary.c b/control/auxiliary.c
index fdc35060bdd9e4f600591169a59cf0a8307e5f02..b8300d76c2190b24ef77db5951cd6f08a7b779e9 100644
--- a/control/auxiliary.c
+++ b/control/auxiliary.c
@@ -187,19 +187,19 @@ int CHAMELEON_Version(int *ver_major, int *ver_minor, int *ver_micro)
* @retval Element size in bytes
*
*/
-int CHAMELEON_Element_Size( cham_flttype_t type )
+ssize_t CHAMELEON_Element_Size( cham_flttype_t type )
{
switch( cham_get_flttype(type) ) {
- case ChamByte: return 1;
- case ChamInteger16: return sizeof(int16_t);
- case ChamInteger32: return sizeof(int32_t);
- case ChamInteger64: return sizeof(int64_t);
- case ChamRealHalf: return 2;
- case ChamRealFloat: return sizeof(float);
- case ChamRealDouble: return sizeof(double);
- case ChamComplexHalf: return 4;
- case ChamComplexFloat: return 2*sizeof(float);
- case ChamComplexDouble: return 2*sizeof(double);
+ case ChamByte: return (ssize_t)1;
+ case ChamInteger16: return sizeof(int16_t);
+ case ChamInteger32: return sizeof(int32_t);
+ case ChamInteger64: return sizeof(int64_t);
+ case ChamRealHalf: return (ssize_t)2;
+ case ChamRealFloat: return sizeof(float);
+ case ChamRealDouble: return sizeof(double);
+ case ChamComplexHalf: return (ssize_t)4;
+ case ChamComplexFloat: return sizeof(float) * 2;
+ case ChamComplexDouble: return sizeof(double) * 2;
default: chameleon_fatal_error("CHAMELEON_Element_Size", "undefined type");
return CHAMELEON_ERR_ILLEGAL_VALUE;
diff --git a/control/descriptor.c b/control/descriptor.c
index 4a1f2ef0073d1d8b8ece092ac856809b9031a4ed..ce86f785ceabebc24be946ddae745845965572ae 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 05706af51d6ea745279d07d76f69aedabdbe0763..ec8a4e8336e2483052c819007e886d276472c606 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 10930a2565397f9067c9884e8780996d34da2638..b9a7038c42b5c81fb85584782bbb87ca51bddd49 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 2bf41a44e83fbc7bf4051e1d25517dc9d947fbab..39c060adfe232fa4c4e9d67c750b4a361cec7f29 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 067f6693d8dfbb21cce9b232bbb34a0c1cd5c9d4..7638428afdd67be4a21eb379af208acae68d61d1 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 aba81ab310b410bcac2346d269ef5a110aca9d5c..fbae30a5591dc04f3adefcc55086d5c3f920d8ff 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 f89c2b017f38d1be44c8a366252028b93c8da1cc..e59746269313121432d4de792cc459bcb92032d0 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 b472e0725d5f6dc33b6e66d8bf883a4b642a0a50..30caf368f449be5a120ad8cb7ca2063131c02d36 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 1fe156e99a8a8b88f556001659ef9240bd0780b2..76db96fd6d53134a6126bcbbbc3c0e49a2e9639b 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 070fdb23ad94c9daa5891a3794d20d545a482d2b..311a97304082b7bb866ddcde21c79b324a448e4d 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 84bd27fa68151d9ac6cb69f11140a2a804407fe6..ecfee8683d993edc1231270c6d1674d74148e108 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 76a2b4fa08c49b62e346d3ba162f74884911d61a..9a0c355a4b20eac024bb0e6fdf95749c57467947 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 a9c5431c65c8fae8c30c7797ad035b3db73b2d16..3eac607c8512232298f33be0ec21a3cf5ce3c992 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 4b167ac13bb5a8e27ea21cd5a848aad4a1398c70..62685d3394bd8deb96fa03b74f4ce985b9a30e89 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 5407d587eb4c9824ceba5b61734f9e2cfb6103c6..c183781e15435541a39ad476168b73f2b1ad89ba 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 c995e883e9a16fc6a15444d71f9f461f5a36ac55..17c8649e62ee04589a52c280e94ac7460c269784 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 9f3a665bd569417e1bd3ec4a54c744e71d88e597..df2f8c8880201d1f33e879b208bee0766ba354d3 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 dcd01f19d86fdab5eba4d01992e6b9d13dd67038..d5f581466130ea8a66824767ca591b94c027a67f 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 a2c06235dc3fb95f057e4c6a31e2b2bf8821d920..950d1f9c2ab63a61c5a3737ebaa6e096c5700ecd 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.h b/include/chameleon.h
index cb7e23dedaf7330ab0deffef714f6d9bc01fb7b1..82e9efab8108e10c0cec8f39ef36d5440d46d47d 100644
--- a/include/chameleon.h
+++ b/include/chameleon.h
@@ -141,7 +141,7 @@ int CHAMELEON_Lapack_to_Tile( void *Af77, int LDA, CHAM_desc_t *A ) __attribute_
int CHAMELEON_Tile_to_Lapack( CHAM_desc_t *A, void *Af77, int LDA ) __attribute__((deprecated("Please refer to CHAMELEON_Desc2Lap() instead")));
/* Descriptor */
-int CHAMELEON_Element_Size( cham_flttype_t type );
+ssize_t CHAMELEON_Element_Size( cham_flttype_t type );
int CHAMELEON_Desc_Create_User( CHAM_desc_t **desc, void *mat, cham_flttype_t dtyp, int mb, int nb, int bsiz,
int lm, int ln, int i, int j, int m, int n, int p, int q,
diff --git a/include/chameleon/getenv.h b/include/chameleon/getenv.h
index 74c8ecc87c267c62af3c34ac07adfef9bae2e943..5656d71019e8a92297e2cbd83292f753e380ce4f 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 d14ee9996087df3d6ee4357e649f9e93c832a0a4..6cb009e52e2c04e61e5fcb0ecdef341acd8a7624 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 b7930ff7134fe38b504b9d14e522147fa52ea6cd..cf1916f2b515b3470a234131bd54d90d508b438c 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 0e9120cd3bbe8c0511000213cbe57b5899e5d955..4e7d1615f27c502429d5cf4ab02821ccccff1f48 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 8e5223087f8ecc53bd2c06016521fc42a815618b..b249d77563876715518dc9892db2d60a58e25154 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 5e7254a28548bfac4778c49850daa543197f69fe..a81f0d08eef1fb94b6846606b5e63aae64ab075c 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 d3d69856f7ea06af076879d63c5cc629a097848a..b340023e18b95175e006e3ce8b9ab692839ec67c 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 9607d83e901a779375cd70703ec49dec7fc96f10..092cf36d41b28e16c3ba53f35b13307d3ba53002 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 11c13503f7d9c699e92f5a59b6b64a6260974c62..251a06250fdfe32224260cd3c39ae55e954ed8b8 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 1c898a09b5f4a418279161e56653e3f9d2b0ebdd..3946e1365ea1b9d5231d20d4a6d32d51ba3da62c 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 88b441a47908e99b098afa7bed3b859ee129144b..7c1dc5fd8626a3a10e05e03a240e8db20dc8c770 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 cfcfece9f764ceb4569ec3fb8502971b990b1909..b30b98b6382828c09d5fcd322154ff5645ff002a 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 244b097ffc64d4d9fb4502cf363488892181ce21..bf094e7d350c19df9a3895b70e9863f6b7a367ec 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 71df7316e31b441ca726fed36f5c16bc59cc193b..d52d745913f2c7e6036cf8021781f025a9742c53 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 59fedc2d4cc372194c92bba20893d08ab12cc23b..1a958340c17b50debb2477dcc9fe56e027a61646 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 09f5985ab927ddc8e36f712d6649fb94d7cc30d2..72d43c18e3bf3d866f3dd49364bbae72b2cde295 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 3ce8033238267a739f924098647235f515dd3f5e..a9bf0aa6f0f051f47c95626c51b221ac3b54a31a 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 fa31d578d65d5962a72427d21540fec7ec39500a..6f96f3f0155dcac1e6f65e167a76f0aff6b8f368 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 0751ca9710821f703298a2070e91f66908029287..bc8f3b27fe41c0242cbfd0e1ff4180234c39c4f8 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 d6896c5e3197b5eef47ae48f4634b60302f36713..b3c153edb660c119d4ee7fec693bcd30e6820812 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 53c593ad4079c0f46050010c40e389828472ffb3..a012eb8aae4fe4f4cfe12312f620c461750c789a 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 42a4f209d05f370acaf3559fd1c6dd959030e0dc..92f20f724e502491e748c16dcbc71180f8b1b6d2 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 46e946d9d4d3ec8208b3f0e9f0038910c2f2fd65..2c18447615b7d1e4720dd40b5c3a6106d30f13f6 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 ae5602c183a6e7131b75dd2ba02c154c89f7f147..94b837146e51bd66479ed53ee87834da2e5343f5 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 310e5f5bf3f6f8890d16fc9da7b33f7f0f9770ed..a1cbf529de11c1cd02881848bfec25adc5433395 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 51711401d19f59f7ad63d7d810802d472de4f944..b300c124a6a9965088d85cce0d2252fa3b4933e0 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 f75048d01b5df9d2e8b1f11ea64f011f5a21ebbd..87ec30c43520095ddd4e11ed79a38fbe56ebdeca 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 c974d5523e4e74c7c0f14d7e12e4c68574b1550f..ea36cb1bad42c3ff9263f56b306408e3e0c872aa 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 b17d9ea27ea04ff2ec12e0d01923e67ee3ed77a2..2ff3022588d8117bdb520692d318cc91775045e0 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 5a4d1433ffb8e05d6c5c6487184436b4bc89f6cb..2408c59a98c4c02bb66e4881d297b85567d817c8 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 dd11d04a3d200dd44333fff9adfe1322d545c165..09085a385fd69bcfd7f2122cf46b00908aa21f0e 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 6d174ffb1ce5b11bf1882bd137a97281d3c72548..a6d4d7577b07f3f2563e446e8b858cbacf26941d 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 f7dcb8b5e8429e51ad28ffff2f00ea4ab1d99b49..1f636d91af07ed3ecc42bc975b56211a3642c21f 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 ceeceba02cdd482d158e90132ad8ae9b60e70f91..c39a70218ec3d1c4444bc2f59f449408a81c58b7 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 5cb7507ac00a69868801e546f58945b7b3409123..10ed12f0548c198d4aac39a723fb2647ef40441f 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 71b8d6dd56a5552d74a3f5e71673da6e27d8eba7..f84fb6b00d93e3b0229becfdc240ef4673a16e11 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 479a91f322c394ed3faa5f04e1d3ac6096dff788..816d654b92e18d1425a253279f8c86d4bb5b566a 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 2899c9dee3a94f7928052d9721a8e0389f4f0d29..7623d0f24573641c72631f9ee9d52b3aa9286913 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 19d47f23fa7d93dbb38a5cccb984e138b9721ae3..f18fbada5b5442c73aa64afc8e26efe5b7d3058c 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 d6f35a056c2302c302e46af4eb8030d2b58c4e7f..3e33f0f0b9803bff0f609eab759591886e0c4280 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 368821eedb10f575ed4f0b5d4405d3e041201540..e07c42ab9e235ae5890913affa1c9e8a1fdd5feb 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 cf62105cc8d9f4a2ac1452372f331be8947f0794..b2fc5e0647a73ea373b83237883d40a8b94b9d72 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 6b3c2fd24020b2138c170b848f2534c7c9c35f41..33a06056f2f2294c4353c6af6e3027474496664f 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 687a3d7c795e1ab78304df2b60e1784bad08dd0f..fb0be7a37d9161e71530373dd6ab61c0b0d70f3e 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 9165b869eb95fa98d44774d4a1ee0de0155b8e48..af93617e25146af249b249141386f716ae899ad1 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 08e7985a801e7b5472fe1489df08bd4039319ae5..df150ca1c2b346296a21949c97b5b244f9a10546 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 d182060c87ff8cbc9d219dcfd51f5403f3944a55..2d1657fdc988c6ec7ec792ba5eeac149a4793924 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 35ef84ba0ac7e9865788e73665dcb6269537e04e..ca50dc598a6829b276f377c2bd3fa963c739a53e 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 2d42111fe968fd9803f076c54106289674fb4728..d75b0a7fed36e1f01261e59836b24f8bef537f3e 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 fb7fd0d20586ab5cece85eff78e748c3339669cf..c420b02d72ed435d0f42f00aabaa117e2bdf64a0 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 a3412017b06195f9f1f47a4b5225700ddb4ad681..158f6dfc32843a415c7caadb8856af955b8ffcb8 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 d9ecddad6e6f7941f8f239a6cf1afdbf4b5bcaf8..9c2b460eea56528a4442af94e9f47c9e6a3c5690 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 c87f6e9eeaf86931be50e0dc06e4bb13eb77b4b3..72c63085d549476e2effac434f070d927d93ce90 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 6bf5cec0d6e178ab09477485e7cbf7cca12be607..e624b269ebff483d650f8a29fc6db2bab4b983bb 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 b38d0374f720523a1d4c1805c11574afb2908a34..adbb2d113f0042d70861388f8490b37fde481de7 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 dcf4f891d7602f00541e51565a0913b19f52a377..a4efca0f44dd33b787c901d85287567dafb83f31 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 1ec9b56302ebe0509ca9415acc01604871352b6b..59048da7dd0e24b2619dba076e414e2edc9dbe96 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 bd37dfb94fd3efa0a3538fd7660f2de1e7a18856..38ad7791f6d08bf08bc2454b10b6d544e38a0aca 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 5dc1b41d4b40352e84803abc3621126c4ee07931..354c0c3d1c14a03f7b5026ee7b5a9ccd5012faed 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 7399d260dfe8e453ea5a85cc8e01ad8bb617c071..6278fd53f84bcb02202c4298793935479f6da9e7 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 4217e59192362dc30441d935da316c07b457f3e8..c1a28209a1d08e915d8fdec80d8985f16ddf26e1 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 3196b21a4f78ad6a4b9fd4014dd64ba097646ef6..450f7c4ea1841d3c3b57187b3dd91749360322b3 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 );