diff --git a/.gitignore b/.gitignore index 31bc615..5ba10a9 100755 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,5 @@ log* */**/**.o launch_* eEcomp +*massif* +*xtmemory* diff --git a/dimension_t/src/dimension_t/dimension_t.c b/dimension_t/src/dimension_t/dimension_t.c index 592510d..a973273 100644 --- a/dimension_t/src/dimension_t/dimension_t.c +++ b/dimension_t/src/dimension_t/dimension_t.c @@ -1,5 +1,7 @@ #include "dimension_t/dimension_t.h" +#define min(x,y) (((x)<(y))?(x):(y)) + bool endian=true; bool isLessEqThan(long int a, long int b) { return a <= b; } @@ -10,6 +12,14 @@ long int incr(long int i) { return i + 1; } long int decr(long int i) { return i - 1; } dimension* init_dim(size_t *t, size_t sz){ + dimension *d = malloc(sizeof(dimension)); + d->size=sz; + d->perm=t; + updateRankDim(d); + return d; +} + +dimension* init_copy_dim(size_t *t, size_t sz){ dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(t,sz); updateRankDim(d); return d; @@ -18,6 +28,66 @@ dimension * create_dim(size_t sz){ return CREATE_PERMUTATION_TYPE_SIZE_T(sz); } +void free_dimension(dimension *d){ + free_permut_TYPE_SIZE_T(d); +} + +dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){ + if(minusSubdim < (root->size)){ + dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, (root->size)-minusSubdim); + updateRankDim(d); + return d; + } + return NULL; +} + +dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){ + if(minusSubdim < (root->size)){ + dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T((root->perm)+minusSubdim, (root->size)-minusSubdim); + updateRankDim(d); + return d; + } + return NULL; +} + +dimension* sub_copy_dim_head(dimension *root, size_t subdim){ + if(subdim < (root->size)){ + dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T(root->perm, subdim); + updateRankDim(d); + return d; + } + return NULL; +} + +dimension* sub_copy_dim_tail(dimension *root, size_t subdim){ + if(subdim < (root->size)){ + dimension *d = INIT_COPY_PERMUTATION_TYPE_SIZE_T((root->perm)+(root->size - subdim), subdim); + updateRankDim(d); + return d; + } + return NULL; +} + +void add_copy_dimension(dimension **d, dimension *d0, dimension *d1) { + (*d) = create_dim(d0->size + d1->size); + for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i]; + for (size_t i = 0; i < d1->size; i++) (*d)->perm[d0->size + i] = d1->perm[i]; + updateRankDim(*d); +} + +void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) { + size_t mindim = min(d0->size,d1->size) ; + (*d)=create_dim(mindim); + + for (size_t i = 0; i < mindim; i++) { + if (d0->perm[i] > d1->perm[i]) (*d)->perm[i] = d1->perm[i]; + else (*d)->perm[i] = d0->perm[i]; + } + updateRankDim(*d); +} + + + dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){ if(minusSubdim < (root->size)){ @@ -53,8 +123,6 @@ dimension* sub_dim_tail(dimension *root, size_t subdim){ } void add_dimension(dimension **d, dimension *d0, dimension *d1) { (*d) = create_dim(d0->size + d1->size); - //printf("d size : %ld\n",(*d)->size); - (*d)->perm = malloc(sizeof(size_t)*((*d)->size)); for (size_t i = 0; i < d0->size; i++) (*d)->perm[i] = d0->perm[i]; for (size_t i = 0; i < d1->size; i++) (*d)->perm[d0->size + i] = d1->perm[i]; updateRankDim(*d); diff --git a/dimension_t/src/dimension_t/dimension_t.h b/dimension_t/src/dimension_t/dimension_t.h index c798a59..dcdafd0 100644 --- a/dimension_t/src/dimension_t/dimension_t.h +++ b/dimension_t/src/dimension_t/dimension_t.h @@ -9,12 +9,22 @@ typedef struct PERMUTATION_TYPE_SIZE_T dimension ; dimension * create_dim(size_t size); dimension* init_dim(size_t *t, size_t sz); +dimension* init_copy_dim(size_t *t, size_t sz); +void free_dimension(dimension *d); dimension* sub_minus_dim_head(dimension *t, size_t minusSubdim); dimension* sub_minus_dim_tail(dimension *t, size_t minusSubdim); dimension* sub_dim_head(dimension *t, size_t subdim); dimension* sub_dim_tail(dimension *t, size_t subdim); +dimension* sub_copy_minus_dim_head(dimension *t, size_t minusSubdim); +dimension* sub_copy_minus_dim_tail(dimension *t, size_t minusSubdim); +dimension* sub_copy_dim_head(dimension *t, size_t sub_copydim); +dimension* sub_copy_dim_tail(dimension *t, size_t sub_copydim); + +void add_copy_dimension(dimension **d, dimension *d0, dimension *d1); +void min_copy_dimension(dimension **d, dimension *d0, dimension *d1); + void add_dimension(dimension **d, dimension *d0, dimension *d1); void min_dimension(dimension **d, dimension *d0, dimension *d1); diff --git a/tensor_t/src/kernel_2d_ProdContractnTensor.cl b/tensor_t/src/kernel_2d_ProdContractnTensor.cl index b6af932..d577299 100644 --- a/tensor_t/src/kernel_2d_ProdContractnTensor.cl +++ b/tensor_t/src/kernel_2d_ProdContractnTensor.cl @@ -1,36 +1,75 @@ - - - -__kernel void prodContractnTensorLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){ +__kernel void prodContractnTensor2dLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){ //Get the index of the current element to be processed - size_t i = get_global_id(0); - size_t k, a0_id, a1_id, n0_id, n1_id; - a0_id = i / dSubRank; - a1_id = i % dSubRank; - Mx[i] = 0; + //size_t i = get_global_id(0); + //size_t j = get_global_id(1); + + size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0); + size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1); + + size_t k, n0_id, n1_id; + size_t ind = i * dSubRank + j; + Mx[ind] = 0; for (k = 0; k < dMRank; k++) { - n0_id = a0_id * dMRank + k; - n1_id = a1_id + dSubRank * k; - Mx[i] += M0x[n0_id] * M1x[n1_id]; + n0_id = i * dMRank + k; + n1_id = j + dSubRank * k; + Mx[ind] += M0x[n0_id] * M1x[n1_id]; } } -__kernel void prodContractnTensorLin_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){ +__kernel void prodContractnTensor2dLin_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){ //Get the index of the current element to be processed - size_t i = get_global_id(0); - size_t k, a0_id, a1_id, n0_id, n1_id; - a0_id = i / dSubRank; - a1_id = i % dSubRank; - Mx[i] = 0; + //size_t i = get_global_id(0); + //size_t j = get_global_id(1); + + size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0); + size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1); + + size_t k, n0_id, n1_id; + size_t ind = i * dSubRank + j; + Mx[ind] = 0; for (k = 0; k < dMRank; k++) { - n0_id = a0_id * dMRank + k; - n1_id = a1_id + dSubRank * k; - Mx[i] += M0x[n0_id] * M1x[n1_id]; + n0_id = i * dMRank + k; + n1_id = j + dSubRank * k; + Mx[ind] += M0x[n0_id] * M1x[n1_id]; } } +__kernel void prodContractnTensor2dLiniNotEndian_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){ + //Get the index of the current element to be processed + //size_t i = get_global_id(0); + //size_t j = get_global_id(1); + + size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0); + size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1); + size_t k, n0_id, n1_id; + size_t ind = i + dSubRank * j; + Mx[ind] = 0; + for (k = 0; k < dMRank; k++) { + n0_id = i + dMRank * k; + n1_id = j * dSubRank + k; + Mx[ind] += M0x[n0_id] * M1x[n1_id]; + } +} +__kernel void prodContractnTensor2dLinNotEndian_TYPE_DOUBLE(long unsigned int dSubRank, long unsigned int dMRank, __global const double *M0x , __global const double *M1x, __global double *Mx ){ + + //Get the index of the current element to be processed + //size_t i = get_global_id(0); + //size_t j = get_global_id(1); + + size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0); + size_t j = get_group_id(1)*get_local_size(1) + get_local_id(1); + + size_t k, n0_id, n1_id; + size_t ind = i + dSubRank * j; + Mx[ind] = 0; + for (k = 0; k < dMRank; k++) { + n0_id = i + dMRank * k; + n1_id = j * dSubRank + k; + Mx[ind] += M0x[n0_id] * M1x[n1_id]; + } +} diff --git a/tensor_t/src/kernel_2d_ProdTensor.cl b/tensor_t/src/kernel_2d_ProdTensor.cl index 7e51094..90e660e 100644 --- a/tensor_t/src/kernel_2d_ProdTensor.cl +++ b/tensor_t/src/kernel_2d_ProdTensor.cl @@ -11,7 +11,7 @@ __kernel void prodTensor2dLin_TYPE_FLOAT(long unsigned int M1rank, __global cons Mx[k] = M0x[i] * M1x[j]; } -__kernel void prodTensori2dLin_TYPE_DOUBLE(long unsigned int M1rank, __global const double *M0x , __global const double *M1x, __global double *Mx ){ +__kernel void prodTensor2dLin_TYPE_DOUBLE(long unsigned int M1rank, __global const double *M0x , __global const double *M1x, __global double *Mx ){ //Get the index of the current element to be processed size_t i = get_group_id(0)*get_local_size(0) + get_local_id(0); @@ -51,9 +51,3 @@ __kernel void prodTensori2dLinNotEndian_TYPE_DOUBLE(long unsigned int M0rank, __ Mx[k] = M0x[i] * M1x[j]; } - - - - - - diff --git a/tensor_t/src/kernel_ProdContractnTensor.cl b/tensor_t/src/kernel_ProdContractnTensor.cl index 087521d..868c5eb 100644 --- a/tensor_t/src/kernel_ProdContractnTensor.cl +++ b/tensor_t/src/kernel_ProdContractnTensor.cl @@ -1,6 +1,3 @@ - - - __kernel void prodContractnTensorLin_TYPE_FLOAT(long unsigned int dSubRank, long unsigned int dMRank, __global const float *M0x , __global const float *M1x, __global float *Mx ){ //Get the index of the current element to be processed @@ -64,7 +61,3 @@ __kernel void prodContractnTensorLinNotEndian_TYPE_DOUBLE(long unsigned int dSub Mx[i] += M0x[n0_id] * M1x[n1_id]; } } - - - - diff --git a/tensor_t/src/kernel_ProdTensor.cl b/tensor_t/src/kernel_ProdTensor.cl index a0a785d..32ed368 100644 --- a/tensor_t/src/kernel_ProdTensor.cl +++ b/tensor_t/src/kernel_ProdTensor.cl @@ -33,8 +33,3 @@ __kernel void prodTensorLinNotEndian_TYPE_DOUBLE(long unsigned int M0rank, __glo size_t j = k / M0rank; Mx[k] = M0x[i] * M1x[j]; } - - - - - diff --git a/tensor_t/src/tensor_t/cl_tensor_t.c b/tensor_t/src/tensor_t/cl_tensor_t.c index 50079a1..a038cac 100644 --- a/tensor_t/src/tensor_t/cl_tensor_t.c +++ b/tensor_t/src/tensor_t/cl_tensor_t.c @@ -28,14 +28,15 @@ cl_uint ret_num_devices; \ cl_uint ret_num_platforms; \ cl_int ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms); \ + checkError(ret,__func__,"Error: Failed to get platform ID ");\ ret = clGetDeviceIDs( platform_id, CL_DEVICE_TYPE_DEFAULT, 1, \ &device_id, &ret_num_devices); \ size_t returned_size = 0;\ size_t max_workgroup_size = 0;\ - ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &max_workgroup_size, &returned_size);\ + /*ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &max_workgroup_size, &returned_size);\ checkError(ret,__func__,"Error: Failed to retrieve device info!");\ printf(" ===========================================================++> return size: %ld\n max group sz: %ld\n", returned_size, max_workgroup_size);\ -\ +*/\ /*int gpu = 1;\ ret = clGetDeviceIDs( platform_id, gpu ? CL_DEVICE_TYPE_GPU : CL_DEVICE_TYPE_CPU, 1, \ &device_id, &ret_num_devices); */\ @@ -136,6 +137,7 @@ ret |= clReleaseCommandQueue(command_queue); \ ret |= clReleaseContext(context); \ checkError(ret,__func__,"Error: Failed to clean up! ");\ + free(source_str); #define GEN_cl_FUNC_TENSOR(type)\ \ @@ -214,6 +216,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor dSubRank = dSub0->rank;\ \ }\ + printf("func_cl_name = %s ......... \n",func_cl_name);\ SETUP_cl_KERNEL_(type,file_cl_src,func_cl_name);\ \ /*/ Set the arguments of the kernel */ \ @@ -228,7 +231,7 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor READ_BUF_N_CLEANUP(type)\ \ } \ -\ + \ \ void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz) { \ dimension *dd; \ @@ -262,6 +265,67 @@ void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type READ_BUF_N_CLEANUP(type)\ } \ \ +void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz) {\ +\ + size_t len0 = M0->dim->size - contractionNumber;\ + size_t len1 = M1->dim->size - contractionNumber;\ +\ + size_t* tsub0 = malloc(sizeof(size_t) *len0);\ + size_t* tsub1 = malloc(sizeof(size_t) *len1);\ + size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\ + size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\ + subArray(tsub0, M0->dim->perm, 0, len0, 0);\ + subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\ + subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\ + subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\ + dimension *dSub0 = init_dim(tsub0, len0);\ + dimension *dSub1 = init_dim(tsub1, len1);\ + dimension *dM1 = init_dim(tDk1, contractionNumber);\ + dimension *dM0 = init_dim(tDk0, contractionNumber);\ + dimension *dM;\ + min_dimension(&dM, dM0, dM1);\ + \ + dimension *dd;\ + add_dimension(&dd, dSub0, dSub1);\ + updateRankDim(dd);\ + *MM = CREATE_TENSOR_##type(dd);\ + tensor_##type *M= *MM;\ + char *file_cl_src = "../src/kernel_2d_ProdContractnTensor.cl"; \ + char *func_cl_nameEndian = "prodContractnTensor2dLin_" #type; \ + char *func_cl_nameNotEndian = "prodContractnTensor2dLinNotEndian_" #type; \ + char *func_cl_name; \ + size_t dSubRank;\ + if(endian){\ + func_cl_name = func_cl_nameEndian;\ + dSubRank = dSub1->rank;\ + \ + }else{\ + func_cl_name = func_cl_nameNotEndian;\ + dSubRank = dSub0->rank;\ + \ + }\ + SETUP_cl_KERNEL_(type,file_cl_src,func_cl_name);\ + /*size_t cl_dev_max_w_sz,sz_val;\ + ret = clGetDeviceInfo(device_id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(size_t), &cl_dev_max_w_sz, &sz_val);\ + printf("CL_DEVICE_MAX_WORK_GROUP_SIZE = : %ld, sz :%ld\n ",cl_dev_max_w_sz, sz_val);\ + */\ + /*/ Set the arguments of the kernel */ \ + ret |= clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&dSubRank); \ + ret |= clSetKernelArg(kernel, 1, sizeof(size_t), (void *)&(dM->rank)); \ + ret |= clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M0_mem_obj); \ + ret |= clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M1_mem_obj); \ + ret |= clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&M_mem_obj); \ + checkError(ret,__func__,"Error: Failed to set kernel arguments! ");\ + \ + /*printf("EXEC_cl_2d_KERNEL(type,%ld,%ld,%ld,%ld)\n",dSub0->rank,dSub1->rank,div0Wsz,div1Wsz);\ + */EXEC_cl_2d_KERNEL(type,dSub0->rank,dSub1->rank,div0Wsz,div1Wsz);\ + READ_BUF_N_CLEANUP(type)\ +\ +} \ +\ + + + void checkError(cl_int error, const char *func_name, char *msg) { if (error != CL_SUCCESS) { diff --git a/tensor_t/src/tensor_t/cl_tensor_t.h b/tensor_t/src/tensor_t/cl_tensor_t.h index 9b300ef..71f18e0 100644 --- a/tensor_t/src/tensor_t/cl_tensor_t.h +++ b/tensor_t/src/tensor_t/cl_tensor_t.h @@ -19,7 +19,7 @@ void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \ void cl_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \ void cl2d_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t div0Wsz, size_t div1Wsz); \ -/*void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz);*/ \ +void cl2d_tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t div0Wsz, size_t div1Wsz); \ CL_GENERATE_TENSOR_TYPE(TYPE_FLOAT); CL_GENERATE_TENSOR_TYPE(TYPE_DOUBLE); diff --git a/tensor_t/src/tensor_t/tensor_t.c b/tensor_t/src/tensor_t/tensor_t.c index 5e7bd02..08f7da8 100644 --- a/tensor_t/src/tensor_t/tensor_t.c +++ b/tensor_t/src/tensor_t/tensor_t.c @@ -23,6 +23,27 @@ void printArraySzt(size_t *a, size_t sz,char *msg){ printf("\n"); } + +#define FREE_COORD_\ + free(coord0);\ + free(coord1);\ + free(coord);\ + +#define FREE_t \ + free( tsub0 );\ + free( tsub1 );\ + free( tDk1 );\ + free( tDk0 ); + +#define FREE_dM_S_\ + free_dimension(dM0);\ + free_dimension(dM1);\ + free_dimension(dM);\ + free_dimension(dSub0);\ + free_dimension(dSub1);\ + + + #define GEN_FUNC_TENSOR(type)\ tensor_##type* CREATE_TENSOR_##type(dimension *dim){\ tensor_##type *r_tens=malloc(sizeof(tensor_##type));\ @@ -32,24 +53,37 @@ void printArraySzt(size_t *a, size_t sz,char *msg){ return r_tens;\ }\ \ - tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\ + tensor_##type* CREATE_TENSOR_FROM_CPY_DIM_##type(dimension *dim){\ + tensor_##type *r_tens=malloc(sizeof(tensor_##type));\ + r_tens->dim = init_copy_dim(dim->perm,dim->size);\ + r_tens->x = malloc(sizeof(type)*dim->rank);\ + return r_tens;\ + }\ +\ + void free_tensor_##type(tensor_##type * tens){\ + if(tens){\ + free_dimension(tens->dim);\ + free(tens->x);\ + free(tens);\ + }\ + }\ +/* tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\ dimension *rdim= rootens->dim;\ dimension *dS_t = sub_minus_dim_tail(rdim,rdim->size - minuSubdim);\ if(rankInDim < dS_t->rank){\ dimension *dS_h = sub_minus_dim_head(rdim,minuSubdim);\ tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ ret_ens->dim = dS_h;\ - /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\ + ret_ens->x = malloc(sizeof(type)*dS_h->rank);\ if(endian){\ - ret_ens->x = malloc(sizeof(type)*dS_h->rank);\ for(size_t i=0; irank; ++i){\ - ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\ - /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\ \ }\ }else{\ - ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;\ - \ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\ + }\ }\ return ret_ens;\ }\ @@ -63,15 +97,15 @@ void printArraySzt(size_t *a, size_t sz,char *msg){ dimension *dS_t = sub_minus_dim_tail(rdim,minuSubdim);\ tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ ret_ens->dim = dS_t;\ - if(endian==false){\ ret_ens->x = malloc(sizeof(type)*dS_t->rank);\ + if(endian==false){\ for(size_t i=0; irank; ++i){\ ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\ - /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ - \ }\ }else{\ - ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\ + }\ \ }\ return ret_ens;\ @@ -80,23 +114,21 @@ void printArraySzt(size_t *a, size_t sz,char *msg){ }\ \ tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){\ - /*return sub_minus_tensor_head_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\ dimension *rdim= rootens->dim;\ dimension *dS_t = sub_dim_tail(rdim,rdim->size - subdim);\ if(rankInDim < dS_t->rank){\ dimension *dS_h = sub_dim_head(rdim,subdim);\ tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ ret_ens->dim = dS_h;\ - /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\ - if(endian){\ ret_ens->x = malloc(sizeof(type)*dS_h->rank);\ + if(endian){\ for(size_t i=0; irank; ++i){\ ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\ - /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ - \ }\ }else{\ - ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\ + }\ \ }\ return ret_ens;\ @@ -104,28 +136,142 @@ void printArraySzt(size_t *a, size_t sz,char *msg){ return NULL;\ }\ tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){ \ - /*return sub_minus_tensor_tail_##type(rootens,rootens->dim->size - subdim, rankInDim);*/\ dimension *rdim= rootens->dim;\ dimension *dS_h = sub_dim_head(rdim,rdim->size - subdim);\ if(rankInDim < dS_h->rank){\ dimension *dS_t = sub_dim_tail(rdim,subdim);\ tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ ret_ens->dim = dS_t;\ - if(endian==false){\ ret_ens->x = malloc(sizeof(type)*dS_t->rank);\ + if(endian==false){\ for(size_t i=0; irank; ++i){\ ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\ - /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ - \ }\ }else{\ - ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\ + }\ \ }\ return ret_ens;\ }\ return NULL;\ }\ +*/ \ + tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\ + dimension *rdim= rootens->dim;\ + dimension *dS_t = sub_copy_minus_dim_tail(rdim,rdim->size - minuSubdim);\ + if(rankInDim < dS_t->rank){\ + dimension *dS_h = sub_copy_minus_dim_head(rdim,minuSubdim);\ + tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_h);\ + /*malloc(sizeof(tensor_##type));\ + ret_ens->dim = dS_h;\ + ret_ens->x = malloc(sizeof(type)*dS_h->rank);*/\ + if(endian){\ + /*ret_ens->x = malloc(sizeof(type)*dS_h->rank);\ + */for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\ + /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + \ + }\ + }else{\ + /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\ + }\ + }\ + free_dimension(dS_t);\ + return ret_ens;\ + }\ + free_dimension(dS_t);\ + return NULL;\ + }\ + \ + tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\ + dimension *rdim= rootens->dim;\ + dimension *dS_h = sub_copy_minus_dim_head(rdim,rdim->size - minuSubdim);\ + if(rankInDim < dS_h->rank){\ + dimension *dS_t = sub_copy_minus_dim_tail(rdim,minuSubdim);\ + tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_t);\ + /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ + ret_ens->dim = dS_t;\ + ret_ens->x = malloc(sizeof(type)*dS_t->rank);\ + */if(endian==false){\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\ + }\ + }else{\ + /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\ + }\ + \ + }\ + free_dimension(dS_h);\ + return ret_ens;\ + }\ + free_dimension(dS_h);\ + return NULL;\ + }\ + \ + tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){\ + /*return sub_copy_minus_tensor_head_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\ + dimension *rdim= rootens->dim;\ + dimension *dS_t = sub_copy_dim_tail(rdim,rdim->size - sub_copydim);\ + if(rankInDim < dS_t->rank){\ + dimension *dS_h = sub_copy_dim_head(rdim,sub_copydim);\ + tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_h);\ + /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ + ret_ens->dim = dS_h;\ + ret_ens->x = malloc(sizeof(type)*dS_h->rank);\ + */if(endian){\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\ + /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + }\ + }else{\ + /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\ + /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + }\ + \ + }\ + free_dimension(dS_t);\ + return ret_ens;\ + }\ + free_dimension(dS_t);\ + return NULL;\ + }\ + tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){ \ + /*return sub_copy_minus_tensor_tail_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\ + dimension *rdim= rootens->dim;\ + dimension *dS_h = sub_copy_dim_head(rdim,rdim->size - sub_copydim);\ + if(rankInDim < dS_h->rank){\ + dimension *dS_t = sub_copy_dim_tail(rdim,sub_copydim);\ + tensor_##type *ret_ens = CREATE_TENSOR_##type(dS_t);\ + /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\ + ret_ens->dim = dS_t;\ + ret_ens->x = malloc(sizeof(type)*dS_t->rank);\ + */if(endian==false){\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\ + /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + }\ + }else{\ + /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\ + for(size_t i=0; irank; ++i){\ + ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\ + /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\ + }\ + \ + }\ + free_dimension(dS_h);\ + return ret_ens;\ + }\ + free_dimension(dS_h);\ + return NULL;\ + }\ \ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \ dimension *dd; \ @@ -149,6 +295,7 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ M->x[i] = M0->x[lin0] * M1->x[lin1]; \ /*printf(" M->x[%ld] = M0->x[%ld] * M1->x[%ld] ::: %f = %f * %f \n",i,lin0,lin1, M->x[i] , M0->x[lin0] , M1->x[lin1]);*/\ } \ + FREE_COORD_ ; \ } \ \ \ @@ -203,7 +350,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_## printDebug_dimension(dM0,"dM0");\ printDebug_dimension(dM1,"dM1");*/\ dimension *dM;\ - min_dimension(&dM, dM0, dM1);\ + min_copy_dimension(&dM, dM0, dM1);\ /*printDebug_dimension(dM,"dM");*/\ \ dimension *dd;\ @@ -213,21 +360,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_## *MM = CREATE_TENSOR_##type(dd);\ tensor_##type *M= *MM;\ \ - /*size_t* coord;\ - coord = malloc(sizeof(size_t)* M->dim->size);\ -\ - size_t* coord0 , lin0;\ - coord0 = malloc(sizeof(size_t)* len0);\ - size_t* coord1, lin1;\ - coord1 = malloc(sizeof(size_t)* len1);\ -\ - size_t* coordM0 ;\ - coordM0 = malloc(sizeof(size_t)* M0->dim->size);\ - size_t* coordM1 ;\ - coordM1 = malloc(sizeof(size_t)* M1->dim->size);\ -\ - size_t* Koord ;\ - Koord = malloc(sizeof(size_t)* contractionNumber);*/\ + \ \ size_t a0_id, a1_id, n0_id, n1_id;\ for (size_t i = 0; i < M->dim->rank; i++) {\ @@ -239,11 +372,6 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_## a0_id=i%dSub0->rank;\ a1_id=i/dSub0->rank;\ }\ - /*vCoordFromLin(coord, i, M->dim);\ - subArray(coord0, coord, 0, len0, 0);\ - subArray(coord1, coord, 0, len1, len0);\ - printf("i:%ld=> c0: %ld vs %ld \n",i,LineFromCoord(coord0,dSub0),a0_id);\ - printf("i:%ld=> c1: %ld vs %ld \n",i,LineFromCoord(coord1,dSub1),a1_id);*/\ M->x[i] = 0;\ for (size_t k = 0; k < dM->rank; k++) {\ if(endian){\ @@ -255,19 +383,10 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_## n1_id= a1_id*dM->rank + k;\ }\ M->x[i] += M0->x[n0_id] * M1->x[n1_id];\ - /*vCoordFromLin(Koord, k, dM);\ - concatArray(coordM0, coord0, Koord, 0, 0, len0, 0, contractionNumber);\ - concatArray(coordM1, Koord, coord1, 0, 0, contractionNumber, 0, len1);\ - lin0 = LineFromCoord(coordM0, M0->dim);\ - lin1 = LineFromCoord(coordM1, M1->dim);\ - printf("k:%ld, lin0:%ld, vs n0: %ld\n",k,lin0,n0_id);\ - printf("k:%ld, lin1:%ld, vs n1: %ld\n",k,lin1,n1_id);*/\ - /*M->x[i] += M0->x[lin0] * M1->x[lin1];*/\ - /*printf("M[%ld]:%f += M0[%ld]:%f * M1[%ld]:%f | \n",i,M->x[i],n0_id,M0->x[n0_id],n1_id,M1->x[n1_id]);*/\ - /*printf("k:%ld |i:%ld |lin0:%ld | lin1:%ld | ",k,i,lin0,lin1);*/\ + \ }\ - /*printf("\n");*/\ }\ + FREE_dM_S_ \ }\ struct arg_Prod_##type{\ type *M0x;\ @@ -309,9 +428,10 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ arg_th[i]->M1x=M1->x;\ arg_th[i]->Mx=M->x;\ arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\ - if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\ + arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\ + /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\ else arg_th[i]->endRange = M->dim->rank ;\ - if(endian){\ + */if(endian){\ arg_th[i]->MRank = M1->dim->rank;\ }\ else{\ @@ -322,27 +442,39 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ \ for(size_t i=0; i< nbthread; ++i){\ pthread_join(thrd[i], NULL);\ + free(arg_th[i]);\ }\ \ + free(thrd);\ + free(arg_th);\ } \ \ +struct arg_Pro2d_##type{\ + type *M0x;\ + type *M1x;\ + type *Mx;\ + size_t beginRange;\ + size_t endRange;\ + size_t M0Rank;\ + size_t M1Rank;\ +};\ void* runProd_thread2d_##type(void *arg){\ - struct arg_Prod_##type *arg_t = arg;\ + struct arg_Pro2d_##type *arg_t = arg;\ size_t k;\ for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\ - for (size_t j = 0; j < arg_t->MRank; j++) {\ + for (size_t j = 0; j < arg_t->M1Rank; j++) {\ if(endian){\ - k = i * arg_t->MRank + j;\ + k = i * arg_t->M1Rank + j;\ }\ else{\ - k =i + arg_t->MRank * j ;\ + k =i + arg_t->M0Rank * j ;\ }\ - arg_t->Mx[k] += arg_t->M0x[i] * arg_t->M1x[j];\ + arg_t->Mx[k] = arg_t->M0x[i] * arg_t->M1x[j];\ }\ }\ }\ \ -void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) { \ +void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) { \ dimension *dd; \ add_dimension(&dd, M0->dim, M1->dim); \ (*MM)=CREATE_TENSOR_##type(dd); \ @@ -350,29 +482,29 @@ void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##t \ \ pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\ - struct arg_Prod_##type **arg_th = malloc( nbthread * sizeof(struct arg_Prod_##type *));\ + struct arg_Pro2d_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2d_##type *));\ \ for(size_t i = 0; i < nbthread; ++i){\ - arg_th[i]=malloc(sizeof(struct arg_Prod_##type));\ + arg_th[i]=malloc(sizeof(struct arg_Pro2d_##type));\ arg_th[i]->M0x=M0->x;\ arg_th[i]->M1x=M1->x;\ arg_th[i]->Mx=M->x;\ - arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\ - if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\ - else arg_th[i]->endRange = M->dim->rank ;\ - if(endian){\ - arg_th[i]->MRank = M1->dim->rank;\ - }\ - else{\ - arg_th[i]->MRank = M0->dim->rank;\ - }\ - pthread_create(&thrd[i], NULL, runProd_thread_##type, (void*)arg_th[i]);\ + arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\ + arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\ + /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\ + else arg_th[i]->endRange = M0->dim->rank ;\ + */arg_th[i]->M1Rank = M1->dim->rank;\ + arg_th[i]->M0Rank = M0->dim->rank;\ + pthread_create(&thrd[i], NULL, runProd_thread2d_##type, (void*)arg_th[i]);\ }\ \ for(size_t i=0; i< nbthread; ++i){\ pthread_join(thrd[i], NULL);\ + free(arg_th[i]);\ }\ \ + free(thrd);\ + free(arg_th);\ } \ struct arg_ProdContract_##type{\ type *M0x;\ @@ -431,7 +563,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten dimension *dM1 = init_dim(tDk1, contractionNumber);\ dimension *dM0 = init_dim(tDk0, contractionNumber);\ dimension *dM;\ - min_dimension(&dM, dM0, dM1);\ + min_copy_dimension(&dM, dM0, dM1);\ \ dimension *dd;\ add_dimension(&dd, dSub0, dSub1);\ @@ -464,8 +596,12 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten \ for(size_t i=0; i< nbthread; ++i){\ pthread_join(thrd[i], NULL);\ + free(arg_th[i]);\ }\ \ + free(thrd);\ + free(arg_th);\ + FREE_dM_S_ ; \ }\ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\ /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\ @@ -496,7 +632,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten printDebug_dimension(dM0,"dM0");\ printDebug_dimension(dM1,"dM1");*/\ dimension *dM;\ - min_dimension(&dM, dM0, dM1);\ + min_copy_dimension(&dM, dM0, dM1);\ /*printDebug_dimension(dM,"dM");*/\ \ dimension *dd;\ @@ -539,6 +675,11 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten }\ /*printf("\n");*/\ }\ + FREE_COORD_ ; \ + free(coordM0);\ + free(coordM1);\ + free(Koord); \ + FREE_dM_S_ ; \ }\ \ diff --git a/tensor_t/src/tensor_t/tensor_t.h b/tensor_t/src/tensor_t/tensor_t.h index de5a5c7..112d139 100644 --- a/tensor_t/src/tensor_t/tensor_t.h +++ b/tensor_t/src/tensor_t/tensor_t.h @@ -14,15 +14,20 @@ struct tensor_##type{\ };\ typedef struct tensor_##type tensor_##type;\ tensor_##type * CREATE_TENSOR_##type(dimension *dim); \ -tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \ +void free_tensor_##type(tensor_##type * tens); \ +/*tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \ tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \ tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \ tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \ +*/tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \ +tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \ +tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \ +tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \ void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \ void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \ -void tensorProdThread2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \ +void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \ void tensorContractnProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \ void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \ diff --git a/tensor_t/test/Makefile b/tensor_t/test/Makefile index 56ae28e..3ac02e7 100644 --- a/tensor_t/test/Makefile +++ b/tensor_t/test/Makefile @@ -11,7 +11,7 @@ YPERMDIR=$(PWD)/../../ypermutation_t TENSDIR=$(PWD)/.. DIMDIR=$(PWD)/../../dimension_t INCLUDE_DIR=$(PWD)/../src -CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src +CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src #"-D DEBUG=1" LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL #SRC_DIR=$(ROOT_DIR)/src diff --git a/tensor_t/test/is_good.c b/tensor_t/test/is_good.c index c322d95..3271a98 100644 --- a/tensor_t/test/is_good.c +++ b/tensor_t/test/is_good.c @@ -17,6 +17,8 @@ //#include "permutation_t/permutation_t.h" #include "tensor_t/tensor_t.h" +#define VALGRING_ 1 + TEST(rank){ dimension *D=create_dim(4); D->perm[0]=2; @@ -28,6 +30,7 @@ TEST(rank){ tensor_TYPE_FLOAT *tf = CREATE_TENSOR_TYPE_FLOAT(D); EXPECT_EQ(tf->dim->rank, 180); + free_tensor_TYPE_FLOAT(tf); } void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){ @@ -36,18 +39,23 @@ void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){ return; } LOG("================= %s ===============\n",msg); + +#if VALGRING_ for(size_t i=0; idim->rank;++i) LOG("[%ld]: %f ",i,M->x[i]); +#endif LOG("%s","\n"); } void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){ LOG("================= %s ===============\n",msg); +#if VALGRING_ for(size_t i=0; idim->rank;++i) LOG("[%ld]: %lf ",i,M->x[i]); +#endif LOG("%s","\n"); } @@ -67,9 +75,9 @@ TEST(tensorMinusSubhead_ ){ LOG("M0->dim->rank = %ld\n",M0->dim->rank); for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; - endian=false; + //endian=false; size_t rnkId = 1; - tensor_TYPE_FLOAT *s2h = sub_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId); + tensor_TYPE_FLOAT *s2h = sub_copy_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId); print_tensor_float(M0, "M0 for sub"); print_tensor_float(s2h, "sub s2h of M0"); @@ -84,6 +92,9 @@ TEST(tensorMinusSubhead_ ){ EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]); } } + + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s2h); } TEST(tensorMinusSubtail ){ @@ -102,12 +113,13 @@ TEST(tensorMinusSubtail ){ LOG("M0->dim->rank = %ld\n",M0->dim->rank); for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; - - tensor_TYPE_FLOAT *s1t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,5); + tensor_TYPE_FLOAT *s1t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,5); print_tensor_float(M0, "M0 for sub"); print_tensor_float(s1t, "sub s2t of M0 from 5"); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s1t); } @@ -129,7 +141,7 @@ TEST(tensorMinusSubtail ){ //endian=false; size_t rnkId=3; - tensor_TYPE_FLOAT *s2t = sub_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId); + tensor_TYPE_FLOAT *s2t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId); @@ -143,6 +155,8 @@ TEST(tensorMinusSubtail ){ } } + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s2t); } TEST(tensorSubhead_ ){ @@ -161,9 +175,9 @@ TEST(tensorSubhead_ ){ LOG("M0->dim->rank = %ld\n",M0->dim->rank); for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; - endian=false; + //endian=false; size_t rnkId = 1; - tensor_TYPE_FLOAT *s2h = sub_tensor_head_TYPE_FLOAT(M0,2,rnkId); + tensor_TYPE_FLOAT *s2h = sub_copy_tensor_head_TYPE_FLOAT(M0,2,rnkId); print_tensor_float(M0, "M0 for sub"); print_tensor_float(s2h, "sub s2h of M0"); @@ -178,6 +192,8 @@ TEST(tensorSubhead_ ){ EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]); } } + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s2h); } TEST(tensorSubtail ){ dimension *d0=create_dim(3); @@ -196,10 +212,13 @@ TEST(tensorSubtail ){ for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; - tensor_TYPE_FLOAT *s1t = sub_tensor_tail_TYPE_FLOAT(M0,2,5); + tensor_TYPE_FLOAT *s1t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,5); print_tensor_float(M0, "M0 for sub"); print_tensor_float(s1t, "sub s2t of M0 from 5"); + + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s1t); } @@ -222,7 +241,7 @@ TEST(tensorSubtail ){ //endian=false; size_t rnkId=3; - tensor_TYPE_FLOAT *s2t = sub_tensor_tail_TYPE_FLOAT(M0,2,rnkId); + tensor_TYPE_FLOAT *s2t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,rnkId); @@ -236,23 +255,32 @@ TEST(tensorSubtail ){ } } + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(s2t); } TEST(tensorProd ){ dimension *d0=create_dim(3); dimension *d1=create_dim(2); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; - d0->perm[0]=2; - d0->perm[1]=3; - d0->perm[2]=2; - d1->perm[0]=2; - d1->perm[1]=3; + d1->perm[1]=3;//3; - updateRankDim(d0); - updateRankDim(d1); +#else + d0->perm[0]=35; + d0->perm[1]=32; //3; + d0->perm[2]=23; + + d1->perm[0]=32; + d1->perm[1]=23;//3; +#endif + tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0); tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1); @@ -277,18 +305,37 @@ TEST(tensorProd ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); print_tensor_float(Mn,"Mn"); + + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); } TEST(tensorContractnProd_TYPE_FLOAT ){ dimension *d0=create_dim(3); - dimension *d1=create_dim(2); - - d0->perm[0]=2; - d0->perm[1]=3; - d0->perm[2]=2; + dimension *d1=create_dim(3); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; d1->perm[0]=2; - d1->perm[1]=3; + d1->perm[1]=3;//3; + d1->perm[2]=8; + +#else + + + d0->perm[0]=35; + d0->perm[1]=32; //3; + d0->perm[2]=23; + + d1->perm[0]=32; + d1->perm[1]=23;//3; + d1->perm[2]=44; +#endif + updateRankDim(d0); updateRankDim(d1); @@ -308,8 +355,8 @@ TEST(tensorContractnProd_TYPE_FLOAT ){ tensor_TYPE_FLOAT *M; tensor_TYPE_FLOAT *MnO; - tensorContractnProd_TYPE_FLOAT(&M, M0,M1,1); - tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1); + tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2); + tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2); print_tensor_float(M,"M"); @@ -320,12 +367,27 @@ TEST(tensorContractnProd_TYPE_FLOAT ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(MnO); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorContractnProd_TYPE_FLOAT2 ){ dimension *d0=create_dim(3); dimension *d1=create_dim(3); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; + + d1->perm[0]=2; + d1->perm[1]=3;//3; + d1->perm[2]=8; + +#else + d0->perm[0]=35; d0->perm[1]=32; //3; @@ -334,6 +396,7 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){ d1->perm[0]=32; d1->perm[1]=23;//3; d1->perm[2]=44; +#endif updateRankDim(d0); updateRankDim(d1); @@ -365,12 +428,26 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(MnO); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorContractnProd_TYPE_DOUBLE2 ){ dimension *d0=create_dim(3); dimension *d1=create_dim(3); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; + + d1->perm[0]=2; + d1->perm[1]=3;//3; + d1->perm[2]=8; + +#else d0->perm[0]=125; d0->perm[1]=52; //3; @@ -379,6 +456,7 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){ d1->perm[0]=52; d1->perm[1]=63;//3; d1->perm[2]=54; +#endif updateRankDim(d0); updateRankDim(d1); @@ -410,6 +488,10 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){ EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } @@ -417,6 +499,16 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ dimension *d0=create_dim(3); dimension *d1=create_dim(3); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; + + d1->perm[0]=2; + d1->perm[1]=3;//3; + d1->perm[2]=8; + +#else d0->perm[0]=125; d0->perm[1]=52; //3; @@ -425,6 +517,7 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ d1->perm[0]=52; d1->perm[1]=63;//3; d1->perm[2]=154; +#endif updateRankDim(d0); updateRankDim(d1); @@ -456,12 +549,26 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){ dimension *d0=create_dim(3); dimension *d1=create_dim(3); +#if VALGRING_ + d0->perm[0]=5; + d0->perm[1]=2; //3; + d0->perm[2]=3; + + d1->perm[0]=2; + d1->perm[1]=3;//3; + d1->perm[2]=8; + +#else d0->perm[0]=125; d0->perm[1]=52; //3; @@ -470,6 +577,8 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){ d1->perm[0]=52; d1->perm[1]=63;//3; d1->perm[2]=154; +#endif + updateRankDim(d0); updateRankDim(d1); @@ -503,18 +612,36 @@ TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){ EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } TEST(tensorProd_vs ){ + dimension *d0=create_dim(3); dimension *d1=create_dim(2); - d0->perm[0]=12; - d0->perm[1]=13; - d0->perm[2]=12; + +#if VALGRING_ + d0->perm[0]=2; + d0->perm[1]=3; + d0->perm[2]=2; - d1->perm[0]=21; - d1->perm[1]=23; + d1->perm[0]=2; + d1->perm[1]=3; + +#else + + d0->perm[0]=212; + d0->perm[1]=13; + d0->perm[2]=22; + + d1->perm[0]=121; + d1->perm[1]=43; +#endif + updateRankDim(d0); updateRankDim(d1); @@ -529,28 +656,46 @@ TEST(tensorProd_vs ){ for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; - tensor_TYPE_FLOAT *M; tensor_TYPE_FLOAT *Mn; tensorProd_TYPE_FLOAT(&M,M0,M1); - tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + tensorProd_TYPE_FLOAT(&Mn,M0,M1); LOG("M->dim->rank = %ld\n",M->dim->rank); EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorProd_vsThread ){ dimension *d0=create_dim(3); dimension *d1=create_dim(2); - d0->perm[0]=12; - d0->perm[1]=13; - d0->perm[2]=12; +#if VALGRING_ + d0->perm[0]=2; + d0->perm[1]=3; + d0->perm[2]=2; - d1->perm[0]=21; - d1->perm[1]=23; + d1->perm[0]=2; + d1->perm[1]=3; + +#else + + d0->perm[0]=212; + d0->perm[1]=13; + d0->perm[2]=22; + + d1->perm[0]=121; + d1->perm[1]=43; +#endif + + + updateRankDim(d0); updateRankDim(d1); @@ -572,24 +717,43 @@ TEST(tensorProd_vsThread ){ size_t nbthread = 5; tensorProdThread_TYPE_FLOAT(&M,M0,M1,nbthread); - tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + tensorProd_TYPE_FLOAT(&Mn,M0,M1); LOG("M->dim->rank = %ld\n",M->dim->rank); + //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); - EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); - + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorProd_vsThread2d ){ + //endian =true; dimension *d0=create_dim(3); dimension *d1=create_dim(2); - d0->perm[0]=12; - d0->perm[1]=13; - d0->perm[2]=12; +#if VALGRING_ + d0->perm[0]=2; + d0->perm[1]=3; + d0->perm[2]=2; - d1->perm[0]=21; - d1->perm[1]=23; + d1->perm[0]=2; + d1->perm[1]=3; + +#else + + d0->perm[0]=212; + d0->perm[1]=13; + d0->perm[2]=22; + + d1->perm[0]=121; + d1->perm[1]=43; +#endif + + + updateRankDim(d0); updateRankDim(d1); @@ -600,28 +764,30 @@ TEST(tensorProd_vsThread2d ){ LOG("M0->dim->rank = %ld\n",M0->dim->rank); LOG("M1->dim->rank = %ld\n",M1->dim->rank); - for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.01 +1; for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; - tensor_TYPE_FLOAT *M; tensor_TYPE_FLOAT *Mn; size_t nbthread = 5; - tensorProdThread2d_TYPE_FLOAT(&M,M0,M1,nbthread); - tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + tensorProdThrea2d_TYPE_FLOAT(&M,M0,M1,nbthread); + //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1); + tensorProd_TYPE_FLOAT(&Mn,M0,M1); LOG("M->dim->rank = %ld\n",M->dim->rank); + LOG("Mn->dim->rank = %ld\n",Mn->dim->rank); EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } - - - int main(int argc, char **argv){ diff --git a/tensor_t/test_cl/Makefile b/tensor_t/test_cl/Makefile index 32b85e0..b7184f0 100644 --- a/tensor_t/test_cl/Makefile +++ b/tensor_t/test_cl/Makefile @@ -10,6 +10,7 @@ YPERMDIR=$(PWD)/../../ypermutation_t TENSDIR=$(PWD)/.. DIMDIR=$(PWD)/../../dimension_t +#TOOLDIR=$(PWD)/../../ytools_t INCLUDE_DIR=$(PWD)/../src CFLAGS=-I$(INCLUDE_DIR) -I$(YPERMDIR)/src -I$(YTESTDIR)/include_ytest/include -I$(DIMDIR)/src -I$(TENSDIR)/src LDFLAGS=-L$(YTESTDIR) -lytest -lOpenCL @@ -25,6 +26,9 @@ EXECSRC=$(NAME_TEST).c EXEC=launch_$(NAME_TEST)_m +#TOOLRC=$(TOOLDIR)/src/tools_t/tools_t.c +#TOOLSRC_O=$(TOOLSRC:.c=.o) + TENSRC=$(TENSDIR)/src/tensor_t/tensor_t.c TENSRC_O=$(TENSRC:.c=.o) @@ -40,7 +44,7 @@ TOPTARGETS := all clean DEPS=$(DIMDIR) $(YPERMDIR) $(YTESTDIR) $(TENSDIR) -OBJ=$(DIMSRC_O) $(PERMSRC_O) $(TENSRC_O) $(clTENSRC_O) +OBJ=$(DIMSRC_O) $(PERMSRC_O) $(TENSRC_O) $(clTENSRC_O) #$(TOOLSRC_O) LIB_YTEST=$(YTESTDIR)/libytest.so diff --git a/tensor_t/test_cl/is_good.c b/tensor_t/test_cl/is_good.c index 61a1ea8..902c7bb 100644 --- a/tensor_t/test_cl/is_good.c +++ b/tensor_t/test_cl/is_good.c @@ -17,6 +17,8 @@ //#include "permutation_t/permutation_t.h" #include "tensor_t/tensor_t.h" #include "tensor_t/cl_tensor_t.h" +//#include "tools_t/tools_t.h" + TEST(rank){ dimension *D=create_dim(4); @@ -29,6 +31,7 @@ TEST(rank){ tensor_TYPE_FLOAT *tf = CREATE_TENSOR_TYPE_FLOAT(D); EXPECT_EQ(tf->dim->rank, 180); + free_dimension(D); } void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){ @@ -48,8 +51,10 @@ void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){ LOG("%s","\n"); } - + extern long int PRECISION_TYPE_FLOAT ; TEST(tensorProd ){ + PRECISION_TYPE_FLOAT = 10; + dimension *d0=create_dim(3); dimension *d1=create_dim(2); @@ -88,6 +93,11 @@ TEST(tensorProd ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); print_tensor_float(Mn,"Mn"); + + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorContractnProd_TYPE_FLOAT ){ @@ -132,6 +142,10 @@ TEST(tensorContractnProd_TYPE_FLOAT ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(MnO); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorContractnProd_TYPE_FLOAT2 ){ @@ -176,10 +190,17 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); - + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(MnO); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } + extern long int PRECISION_TYPE_DOUBLE; + TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){ + PRECISION_TYPE_DOUBLE=1000; + dimension *d0=create_dim(3); dimension *d1=create_dim(3); @@ -194,7 +215,6 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){ updateRankDim(d0); updateRankDim(d1); - tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0); tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1); @@ -221,6 +241,10 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(MnO); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } @@ -267,6 +291,10 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){ EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } @@ -313,6 +341,10 @@ TEST(tensorContractnProd_TYPE_DOUBLE2 ){ EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } @@ -356,67 +388,26 @@ TEST(TensorProdCL){ print_tensor_float(Mn,"Mn"); + + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } -TEST(VS_cl_tensorContractnProd_TYPE_DOUBLE2 ){ + +TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){ dimension *d0=create_dim(3); dimension *d1=create_dim(3); - d0->perm[0]=125; - d0->perm[1]=52; //3; - d0->perm[2]=63; + d0->perm[0]=512; + d0->perm[1]=48; //3; + d0->perm[2]=64; - d1->perm[0]=52; - d1->perm[1]=63;//3; - d1->perm[2]=154; - - updateRankDim(d0); - updateRankDim(d1); - - - tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0); - tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1); - - LOG("M0->dim->rank = %ld\n",M0->dim->rank); - LOG("M1->dim->rank = %ld\n",M1->dim->rank); - for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; - for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; - - //print_tensor_double(M0,"M0"); - //print_tensor_double(M1,"M1"); - - //tensor_TYPE_DOUBLE *M; - tensor_TYPE_DOUBLE *MnO; - - //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2); - //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2); - //print_tensor_double(M,"M"); - cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); - - - //print_tensor_double(MnO,"MnO"); - - // for(size_t i=0;idim->rank;++i) - // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); - - //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); - - -} - - -TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ - dimension *d0=create_dim(3); - dimension *d1=create_dim(3); - - d0->perm[0]=125; - d0->perm[1]=52; //3; - d0->perm[2]=63; - - d1->perm[0]=52; - d1->perm[1]=63;//3; - d1->perm[2]=154; + d1->perm[0]=48; + d1->perm[1]=64;//3; + d1->perm[2]=240; updateRankDim(d0); updateRankDim(d1); @@ -434,11 +425,197 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ //print_tensor_double(M1,"M1"); tensor_TYPE_DOUBLE *M; - //tensor_TYPE_DOUBLE *MnO; + tensor_TYPE_DOUBLE *MnO; - tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2); + size_t nbth=10; + + //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2); + //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth); //print_tensor_double(M,"M"); //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); + + + //print_tensor_double(MnO,"MnO"); + + // for(size_t i=0;idim->rank;++i) + // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); + + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); + + +} + + + +TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){ + dimension *d0=create_dim(3); + dimension *d1=create_dim(3); + + + d0->perm[0]=512; + d0->perm[1]=48; //3; + d0->perm[2]=64; + + d1->perm[0]=48; + d1->perm[1]=64;//3; + d1->perm[2]=240; + + updateRankDim(d0); + updateRankDim(d1); + + + tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0); + tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1); + + LOG("M0->dim->rank = %ld\n",M0->dim->rank); + LOG("M1->dim->rank = %ld\n",M1->dim->rank); + for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + + //print_tensor_double(M0,"M0"); + //print_tensor_double(M1,"M1"); + + tensor_TYPE_DOUBLE *M; + tensor_TYPE_DOUBLE *MnO; + + size_t nbth=15; + + //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2); + //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth); + //print_tensor_double(M,"M"); + //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); + + + //print_tensor_double(MnO,"MnO"); + + // for(size_t i=0;idim->rank;++i) + // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); + + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); + + +} + + + + + + + +TEST(VS_thrd_tensorContractnProd_TYPE_DOUBLE2 ){ + dimension *d0=create_dim(3); + dimension *d1=create_dim(3); + + + d0->perm[0]=512; + d0->perm[1]=48; //3; + d0->perm[2]=64; + + d1->perm[0]=48; + d1->perm[1]=64;//3; + d1->perm[2]=240; + + updateRankDim(d0); + updateRankDim(d1); + + + tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0); + tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1); + + LOG("M0->dim->rank = %ld\n",M0->dim->rank); + LOG("M1->dim->rank = %ld\n",M1->dim->rank); + for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + + //print_tensor_double(M0,"M0"); + //print_tensor_double(M1,"M1"); + + tensor_TYPE_DOUBLE *M; + tensor_TYPE_DOUBLE *MnO; + + size_t nbth=10; + + //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2); + //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth); + tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbth); + //print_tensor_double(M,"M"); + //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); + + + //print_tensor_double(MnO,"MnO"); + + // for(size_t i=0;idim->rank;++i) + // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); + + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); + + +} + + + + + + + +#if 1 + + +TEST(VScltensorContractnProd_TYPE_DOUBLE2 ){ + dimension *d0=create_dim(3); + dimension *d1=create_dim(3); + + d0->perm[0]=512; + d0->perm[1]=48; //3; + d0->perm[2]=64; + + d1->perm[0]=48; + d1->perm[1]=64;//3; + d1->perm[2]=240; + + updateRankDim(d0); + updateRankDim(d1); + + + tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0); + tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1); + + LOG("M0->dim->rank = %ld\n",M0->dim->rank); + LOG("M1->dim->rank = %ld\n",M1->dim->rank); + for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + + //print_tensor_double(M0,"M0"); + //print_tensor_double(M1,"M1"); + + tensor_TYPE_DOUBLE *M; + tensor_TYPE_DOUBLE *MnO; + + size_t nbth = 10; + + tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth); + //print_tensor_double(M,"M"); + cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); //tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2); //print_tensor_double(MnO,"MnO"); @@ -446,10 +623,69 @@ TEST(VStensorContractnProd_TYPE_DOUBLE2 ){ // for(size_t i=0;idim->rank;++i) // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); - //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); } + +TEST(VScl2dtensorContractnProd_TYPE_DOUBLE2 ){ + dimension *d0=create_dim(3); + dimension *d1=create_dim(3); + + d0->perm[0]=512; + d0->perm[1]=48; //3; + d0->perm[2]=64; + + d1->perm[0]=48; + d1->perm[1]=64;//3; + d1->perm[2]=240; + + updateRankDim(d0); + updateRankDim(d1); + + + tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0); + tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1); + + LOG("M0->dim->rank = %ld\n",M0->dim->rank); + LOG("M1->dim->rank = %ld\n",M1->dim->rank); + for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + + //print_tensor_double(M0,"M0"); + //print_tensor_double(M1,"M1"); + + tensor_TYPE_DOUBLE *M; + tensor_TYPE_DOUBLE *MnO; + + size_t nbth = 10; + + tensorContractnProdThread_TYPE_DOUBLE(&M, M0,M1,2,nbth); + //print_tensor_double(M,"M"); + cl2d_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2,16,16); + //cl2d_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2,8,8); + //tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2); + + //print_tensor_double(MnO,"MnO"); + + // for(size_t i=0;idim->rank;++i) + // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); + + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); + +} + + TEST(tensorProd_vs2d ){ dimension *d0=create_dim(3); dimension *d1=create_dim(2); @@ -488,6 +724,11 @@ TEST(tensorProd_vs2d ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); + //print_tensor_float(Mn,"Mn"); } @@ -534,6 +775,11 @@ TEST(tensorProd_vs2d ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); //print_tensor_float(Mn,"Mn"); + + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } TEST(tensorProd_vs2d_Endian ){ @@ -576,10 +822,15 @@ TEST(tensorProd_vs2d_Endian ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); //print_tensor_float(Mn,"Mn"); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } + TEST(tensorProd_vs2d_Endian ){ dimension *d0=create_dim(3); dimension *d1=create_dim(2); @@ -603,8 +854,6 @@ TEST(tensorProd_vs2d_Endian ){ for(size_t i=0; idim->rank;++i) M0->x[i]=i*0.1 +1; for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; - /*print_tensor_float(M0,"M0"); - print_tensor_float(M1,"M1");*/ tensor_TYPE_FLOAT *M; @@ -621,13 +870,16 @@ TEST(tensorProd_vs2d_Endian ){ EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank); //print_tensor_float(Mn,"Mn"); + free_tensor_TYPE_FLOAT(M); + free_tensor_TYPE_FLOAT(Mn); + free_tensor_TYPE_FLOAT(M0); + free_tensor_TYPE_FLOAT(M1); } - +#endif int main(int argc, char **argv){ - run_all_tests_args(argc, argv); return 0; diff --git a/ypermutation_t/src/permutation_t/permutation_t.c b/ypermutation_t/src/permutation_t/permutation_t.c index ae3d951..f5c3cf7 100644 --- a/ypermutation_t/src/permutation_t/permutation_t.c +++ b/ypermutation_t/src/permutation_t/permutation_t.c @@ -43,7 +43,8 @@ int sign(long int a){ }\ PERMUTATION_##type * INIT_PERMUTATION_##type(type *perm, size_t size){\ if (size == 0) return NULL;\ - PERMUTATION_##type *p = CREATE_PERMUTATION_##type(size);\ + PERMUTATION_##type *p = malloc(sizeof(PERMUTATION_##type));\ + p->size = size;\ p->perm = perm ; /*malloc(size*sizeof(type));\ for(size_t i=0;iperm[i] = perm[i];*/\ return p;\ @@ -51,11 +52,16 @@ int sign(long int a){ PERMUTATION_##type * INIT_COPY_PERMUTATION_##type(type *perm, size_t size){\ if (size == 0) return NULL;\ PERMUTATION_##type *p = CREATE_PERMUTATION_##type(size);\ - p->perm = malloc(size*sizeof(type));\ for(size_t i=0;iperm[i] = perm[i];\ return p;\ }\ -\ + void free_permut_##type(PERMUTATION_##type * permut){\ + if(permut){\ + free(permut->perm);\ + free(permut);\ + /*permut=NULL;*/\ + }\ + }\ PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p ){\ if (p == NULL) return NULL;\ PERMUTATION_TYPE_SIZE_T *t_p = malloc(sizeof(PERMUTATION_TYPE_SIZE_T));\ @@ -119,6 +125,7 @@ size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p){\ for (size_t i = 0; i < sz;i++) {\ q = (i + 1) * q + tPlace[i];\ }\ + free(tPlace);\ return q;\ }\ /*complexité sz*sz/2 */\ @@ -158,6 +165,7 @@ size_t TabToPlaceOpt1_##type(const PERMUTATION_##type *p){\ for (long int i = 0; i < sz; i++) {\ q = (i + 1) * q + tPlace[i];\ }\ + free(tPlace);\ return q;\ }\ /* complexité sz*(sz+1)*/\ @@ -221,6 +229,7 @@ PERMUTATION_TYPE_SIZE_T * PlaceToTab_##type(PERMUTATION_##type *p, size_t pl){\ }\ \ for (long int i = 0;i < sz;i++) p->perm[i] = save_perm[tb[i]];\ + free(save_perm);\ return t_p;\ }\ \ diff --git a/ypermutation_t/src/permutation_t/permutation_t.h b/ypermutation_t/src/permutation_t/permutation_t.h index 12e224b..ba6f6e7 100644 --- a/ypermutation_t/src/permutation_t/permutation_t.h +++ b/ypermutation_t/src/permutation_t/permutation_t.h @@ -21,6 +21,7 @@ PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size);\ PERMUTATION_##type * INIT_PERMUTATION_##type(type *perm, size_t size);\ PERMUTATION_##type * INIT_COPY_PERMUTATION_##type(type *perm, size_t size);\ + void free_permut_##type(PERMUTATION_##type * permut);\ PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(const PERMUTATION_##type *p );\ bool IS_PERMUTATION_##type(const PERMUTATION_##type *p );\ size_t TabToPlaceAlgo_##type(const PERMUTATION_##type *p);\ diff --git a/ypermutation_t/test/is_good.c b/ypermutation_t/test/is_good.c index d38b181..4faba21 100644 --- a/ypermutation_t/test/is_good.c +++ b/ypermutation_t/test/is_good.c @@ -24,12 +24,13 @@ TEST(size_permutation) EXPECT_EQ(p->size, 3); PRINTF("test size_permutation2\n"); + free_permut_TYPE_CHAR(p); } TEST(permutation_t_float_trans) { - int n =8; + int n =6; PERMUTATION_TYPE_FLOAT *p = CREATE_PERMUTATION_TYPE_FLOAT(n); PRINTF(" size = %lu \n",p->size); @@ -49,14 +50,14 @@ TEST(permutation_t_float_trans) for(int i = 0; i < p->size; ++i) PRINTF(" (%d: %f) ,",i,p->perm[i]); PRINTF("\n"); - + free_permut_TYPE_FLOAT(p); // sleep(n); } TEST(not_permutation_) { - int n =8; + int n =6; PERMUTATION_TYPE_FLOAT *p = CREATE_PERMUTATION_TYPE_FLOAT(n); PRINTF(" size = %lu \n",p->size); @@ -71,7 +72,8 @@ TEST(not_permutation_) EXPECT_FALSE(IS_PERMUTATION_TYPE_FLOAT(p)); - + + free_permut_TYPE_FLOAT(p); // sleep(n); } @@ -96,6 +98,7 @@ TEST(is_permutation_) EXPECT_TRUE(IS_PERMUTATION_TYPE_FLOAT(p)); + free_permut_TYPE_FLOAT(p); // sleep(n); } @@ -140,18 +143,21 @@ TEST(expect){ TEST(){ - PERMUTATION_TYPE_CHAR *p_char = CREATE_PERMUTATION_TYPE_CHAR(6); + PERMUTATION_TYPE_CHAR *p_char = CREATE_PERMUTATION_TYPE_CHAR(7); p_char->perm[0]='B'; p_char->perm[1]='A'; p_char->perm[2]='Y'; p_char->perm[3]='C'; p_char->perm[4]='D'; p_char->perm[5]='Z'; + p_char->perm[6]='\0'; PERMUTATION_TYPE_SIZE_T *tr_p_char = TRANSLATE_TO_SET_THEORIC_SIZE_T_TYPE_CHAR(p_char); for(int i = 0; i < tr_p_char->size; ++i) PRINTF(" [%d ]%ld ,",i,tr_p_char->perm[i]); PRINTF("p_char == %s\n",p_char->perm); + free_permut_TYPE_CHAR(p_char); + free_permut_TYPE_SIZE_T(tr_p_char); } TEST(){ @@ -171,7 +177,6 @@ TEST(){ p_char->perm[3]='3'; p_char->perm[4]='4'; p_char->perm[5]='5'; - p_char->perm[6]='\0'; PRINTF("init :%s \n",p_char->perm); PERMUTATION_TYPE_SIZE_T *tab_45 = TRANSLATE_TO_SET_THEORIC_SIZE_T_TYPE_CHAR(p_char); @@ -201,6 +206,7 @@ TEST(){ } */ + free_permut_TYPE_CHAR(p_char); } @@ -215,6 +221,7 @@ TEST(overflowPlacePerm){ PERMUTATION_TYPE_SIZE_T *tab_45 = PlaceToTab_TYPE_CHAR(p_char, rank); for(size_t i=0; isize; ++i) PRINTF(" %ld: %ld \n",i, tab_45->perm[i]); PRINTF("ret %ld :%s \n",rank,p_char->perm); + free_permut_TYPE_CHAR(p_char); } #if 0 diff --git a/ytest_t/Makefile b/ytest_t/Makefile index eb7e44a..0587831 100644 --- a/ytest_t/Makefile +++ b/ytest_t/Makefile @@ -10,7 +10,7 @@ BARP_O=$(BARPDIR)/src/bar_progress/bar_progress.o INCLUDE=-I$(PWD)/yftest/include -I$(PWD)/yfmock/include -I$(TOOLDIR)/include -I$(BARPDIR)/include -CFLAGS=-lpthread -Wall -Werror -fpic $(INCLUDE) +CFLAGS=-g -lpthread -Wall -Werror -fpic $(INCLUDE) #"-D DEBUG=1" #LDFLAGS= TOPTARGETS := all clean #update_headers diff --git a/ytest_t/example/compile.sh b/ytest_t/example/compile.sh index 8581626..dde7cee 100644 --- a/ytest_t/example/compile.sh +++ b/ytest_t/example/compile.sh @@ -1,3 +1,3 @@ #!/bin/bash -gcc -o x1 eg1.c -I../include_ytest/include/ -L.. -lytest $1 +gcc -o x1 eg1.c -g -I../include_ytest/include/ -L.. -lytest $1 diff --git a/ytest_t/example/eg1.c b/ytest_t/example/eg1.c index a2ca7a1..b63c7cb 100644 --- a/ytest_t/example/eg1.c +++ b/ytest_t/example/eg1.c @@ -1,5 +1,6 @@ #include "ftest/ftest.h" +#if 1 TEST(foo){ PRINTF("first test\n"); int a=1; @@ -7,35 +8,56 @@ TEST(foo){ } TEST(foo){ /* same name*/ - sleep(2); + //sleep(2); float a=0.001, b=0.0005; PRINTF("after sleeping 2 seconds, we test if %f ?= 2*%f\n",a,b); EXPECT_EQ_TYPE_FLOAT(a,2*b); } +#endif + +#if 0 TEST(foo){ sleep(1); double a=0.001, b=0.0001; LOG("after 1 sec, \n"); EXPECT_LT_TYPE_DOUBLE(b,a); - ASSERT_GE_TYPE_DOUBLE(a,b); - ASSERT_LE_TYPE_DOUBLE(a,b); - LOG("this line will not print"); +// ASSERT_GE_TYPE_DOUBLE(a,b); +// ASSERT_LE_TYPE_DOUBLE(a,b); +// LOG("this line will not print"); } +#endif +#if 0 TEST(){ EXPECT_TRUE(2==1); LOG("this line will print: the precedent expect failed\n"); } +#endif + +#if 1 +TEST(){ + /*EXPECT_TRUE(2==1); + LOG("this line will print: the precedent expect failed\n"); + LOG("hey\n"); + */ +} +#endif + +#if 1 TEST(){ sleep(1); EXPECT_FALSE(2==1); } +#endif + +#if 1 TEST(an_other_test){ LOG("FINAL, no test, only sleep\n"); sleep(2); } +#endif int main(int argc, char **argv){ run_all_tests_args(argc,argv); diff --git a/ytest_t/example/x1 b/ytest_t/example/x1 index 5d45156..d8576ae 100644 Binary files a/ytest_t/example/x1 and b/ytest_t/example/x1 differ diff --git a/ytest_t/include_ytest/include/ftest/ftest.h b/ytest_t/include_ytest/include/ftest/ftest.h index 98fec1b..501bf63 100644 --- a/ytest_t/include_ytest/include/ftest/ftest.h +++ b/ytest_t/include_ytest/include/ftest/ftest.h @@ -317,17 +317,21 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING) do{ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call) \ do{\ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ }while(0); @@ -338,16 +342,20 @@ do{ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ } else { \ @@ -355,15 +363,19 @@ do{ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ }\ @@ -380,17 +392,21 @@ do{ \ do{\ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_ \ do{\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ }while(0); @@ -403,16 +419,20 @@ do{ \ /*IFTESTPASS_(var1,var2);*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ @@ -421,15 +441,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ @@ -448,15 +472,19 @@ do{ \ /*IFTESTPASS_ ;*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_ ;*/ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ @@ -464,15 +492,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -485,15 +517,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ @@ -502,15 +538,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ diff --git a/ytest_t/include_ytest/include/ftest/ftest_array.h b/ytest_t/include_ytest/include/ftest/ftest_array.h index b4da469..55cbaa9 100644 --- a/ytest_t/include_ytest/include/ftest/ftest_array.h +++ b/ytest_t/include_ytest/include/ftest/ftest_array.h @@ -17,17 +17,24 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ \ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ \ }else { \ @@ -36,16 +43,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -66,16 +80,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ @@ -84,16 +105,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -107,16 +135,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ @@ -126,16 +161,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ diff --git a/ytest_t/include_ytest/include/tools_t/tools_t.h b/ytest_t/include_ytest/include/tools_t/tools_t.h index 6f20a20..c620156 100644 --- a/ytest_t/include_ytest/include/tools_t/tools_t.h +++ b/ytest_t/include_ytest/include/tools_t/tools_t.h @@ -23,8 +23,6 @@ #define F_ERR stderr #endif - - /* #ifndef SECOND #define SECOND 0 @@ -38,6 +36,14 @@ double diff_timespec_milliseconds(struct timespec time_stop, struct timespec tim long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start); */ +#if 1 + +extern long int PRECISION_TYPE_FLOAT ; +extern long int PRECISION_TYPE_DOUBLE ; +extern long int PRECISION_TYPE_L_DOUBLE ; + +#endif + void gotoxy(int x, int y); //void get_cursor_position(int *col, int *rows); diff --git a/ytest_t/libytest.so b/ytest_t/libytest.so index a823520..a1c3a34 100644 Binary files a/ytest_t/libytest.so and b/ytest_t/libytest.so differ diff --git a/ytest_t/test/is_good.c b/ytest_t/test/is_good.c index c533c49..dc15b68 100644 --- a/ytest_t/test/is_good.c +++ b/ytest_t/test/is_good.c @@ -56,7 +56,7 @@ TEST(){ TEST(){ - sleep(3); +// sleep(3); int a = 5; long b = 5; ASSERT_EQ(a,b); @@ -66,7 +66,7 @@ TEST(){ } TEST(expect){ - sleep(2); +// sleep(2); int a = 5; int b = 6; EXPECT_EQ(a,b); @@ -96,8 +96,11 @@ TEST(lessThan){ EXPECT_LT(a,b); EXPECT_LT(b,a); + double da=0.1,db=0.2; + EXPECT_LT_TYPE_DOUBLE(da,db); + EXPECT_LT_TYPE_DOUBLE(db,da); } - +#if 0 TEST(sleep){sleep(2);} TEST(sleep){sleep(2);} TEST(sleep){sleep(2);} @@ -140,8 +143,10 @@ TEST(sleep){sleep(1);} TEST(sleep){sleep(1);} TEST(sleep){sleep(1);} TEST(sleep){sleep(1);} +#endif +#if 1 MOCK_FUNC(int, f_mock, (), ()) EXPECT_MOCK_CALL(int,f_mock, (),false, 2) { @@ -313,6 +318,7 @@ TEST(f7_mock_test){ PRINTF("second call f7 : %d\n",v1); } +#endif int main(int argc, char **argv){ diff --git a/ytest_t/yftest/include/ftest/ftest.h b/ytest_t/yftest/include/ftest/ftest.h index 98fec1b..501bf63 100644 --- a/ytest_t/yftest/include/ftest/ftest.h +++ b/ytest_t/yftest/include/ftest/ftest.h @@ -317,17 +317,21 @@ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING) do{ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call) \ do{\ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ }while(0); @@ -338,16 +342,20 @@ do{ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ } else { \ @@ -355,15 +363,19 @@ do{ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ - PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ + PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ }\ @@ -380,17 +392,21 @@ do{ \ do{\ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_ \ do{\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ }while(0); @@ -403,16 +419,20 @@ do{ \ /*IFTESTPASS_(var1,var2);*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ @@ -421,15 +441,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ @@ -448,15 +472,19 @@ do{ \ /*IFTESTPASS_ ;*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_ ;*/ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ @@ -464,15 +492,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -485,15 +517,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ @@ -502,15 +538,19 @@ do{ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ + char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ - ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ + free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ diff --git a/ytest_t/yftest/include/ftest/ftest_array.h b/ytest_t/yftest/include/ftest/ftest_array.h index b4da469..55cbaa9 100644 --- a/ytest_t/yftest/include/ftest/ftest_array.h +++ b/ytest_t/yftest/include/ftest/ftest_array.h @@ -17,17 +17,24 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ \ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ \ }else { \ @@ -36,16 +43,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -66,16 +80,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ @@ -84,16 +105,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ @@ -107,16 +135,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ @@ -126,16 +161,23 @@ do{ \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ - for(size_t i=0; i < min(sz1,sz2);++i) \ - PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + for(size_t i=0; i < min(sz1,sz2);++i) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ - if (!(var1[i] OP var2[i])) PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ - ,#var1,i, type##_TO_STR(var1[i]), #var2,i, type##_TO_STR(var2[i])); \ + if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ + char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ + PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ + ,#var1,i, str_var1, #var2,i, str_var2); \ + free(str_var1); free(str_var2);\ + }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ diff --git a/ytest_t/yftest/src/ftest/ftest.c b/ytest_t/yftest/src/ftest/ftest.c index c1b47ca..a63302b 100644 --- a/ytest_t/yftest/src/ftest/ftest.c +++ b/ytest_t/yftest/src/ftest/ftest.c @@ -34,6 +34,7 @@ struct failed_lists{ char *name; struct failed_lists *next; }; +void clear_all_falied_list(struct failed_lists **flist); #define default_ordered 0 #define default_unicolour 0 @@ -188,7 +189,7 @@ void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_f tmp_failed_l = tmp_failed_l->next; } tmp_failed_l = malloc(sizeof(struct failed_lists)); - tmp_failed_l->name = malloc(strlen(name_failed)); + tmp_failed_l->name = malloc(strlen(name_failed)+1); strcpy(tmp_failed_l->name, name_failed); tmp_failed_l->next = NULL; rec_tmp->next = tmp_failed_l; @@ -196,7 +197,7 @@ void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_f } else{ *fn_failed_list = malloc(sizeof(struct failed_lists)); - (*fn_failed_list)->name = malloc(strlen(name_failed)); + (*fn_failed_list)->name = malloc(strlen(name_failed)+1); strcpy((*fn_failed_list)->name, name_failed); (*fn_failed_list)->next = NULL; } @@ -240,7 +241,7 @@ size_t extract_num__f(const char *name_f){ /* TEST_funcname___NUM -> TEST(funcname) */ char* extract_func_edited_TEST_from_exec_func_name(char* func_name){ size_t len=strlen(func_name); - char *ret_name=malloc(len); + char *ret_name=malloc(len+1); strcpy(ret_name, func_name); char *pad="____"; size_t len_pad=strlen(pad); @@ -266,15 +267,17 @@ void setup_variables_before_exec(){ size_t len_bp = strlen(bar_progress); size_t len_db = strlen(default_bar_progress); if( len_bp >= len_db ){ - char *tmp_bp=malloc(len_bp); + char *tmp_bp=malloc(len_bp+1); strcpy(tmp_bp,bar_progress); tmp_bp[2]='u'; + free(bar_progress); bar_progress=tmp_bp; } else{ char *tmp_bp=malloc(len_bp); strcpy(tmp_bp,default_bar_progress); tmp_bp[2]='u'; + free(default_bar_progress); default_bar_progress=tmp_bp; } } @@ -569,7 +572,7 @@ void extract_to_array_TYPE_STRING(char * in_str){ val[cur_val++]='\0'; PRINT_DEBUG("val_str=(((%s) cur_val=[%ld]\n",val,cur_val); - array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)); + array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)+1); strcpy(array_TYPE_STRING[cur_array_TYPE_STRING++],val); cur_val=0; } @@ -578,10 +581,11 @@ void extract_to_array_TYPE_STRING(char * in_str){ val[cur_val++]='\0'; PRINT_DEBUG("val_str=(%s) cur_val=[%ld]\n",val,cur_val); - array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)); + array_TYPE_STRING[cur_array_TYPE_STRING]=malloc(strlen(val)+1); strcpy(array_TYPE_STRING[cur_array_TYPE_STRING++],val); } + free(val); } @@ -736,17 +740,18 @@ bool expected_##OP##_name_##type(type var1, type var2,const char * name){ }\ bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int sz2){ \ if(sz1 OP sz2){\ - size_t count=0;\ if(sz1 == sz2){\ + size_t count_ = 0;\ for(size_t i=0;iname = malloc(strlen(name)); + f_static->name = malloc(strlen(name)+1); strcpy(f_static->name,name); f_static->run = run; f_static->next = NULL; @@ -930,7 +935,7 @@ append_func(void (*run)(void), char *name){ else{ struct func *tmp = malloc(sizeof(struct func)); tmp->run = run; - tmp->name = malloc(strlen(name)); + tmp->name = malloc(strlen(name)+1); strcpy(tmp->name,name); tmp->next = NULL; f_static->next = tmp; @@ -1002,7 +1007,10 @@ stat_end_run(size_t ntst, struct timespec start_t){ bool is_in_array_##type(type *array, type val){\ bool found = false;\ for(size_t i = 0; i < cur_array_##type; ++i){\ - PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\ + /*char * strarr = type##_TO_STR(array[i]), *strval = type##_TO_STR(val);\ + PRINT_DEBUG("compare |%s| in array and val: |%s|\n",strarr, strval);\ + free(strarr);free(strval);\ + */PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\ if(COMPARE_N_##type((void*)(array[i]),(void*)val ) == 0 ){\ found = true;\ break;\ @@ -1016,6 +1024,9 @@ bool is_in_array_##type(type *array, type val){\ bool is_in_array_##type(type *array, type val){\ bool found = false;\ for(size_t i = 0; i < cur_array_##type; ++i){\ + /*char * strarr = type##_TO_STR(array[i]), *strval = type##_TO_STR(val);\ + PRINT_DEBUG("compare |%s| in array and val: |%s|\n",strarr, strval);\ + free(strarr);free(strval);*/\ PRINT_DEBUG("compare |%s| in array and val: |%s|\n",type##_TO_STR(array[i]), type##_TO_STR(val));\ if(COMPARE_N_##type((void*)(&array[i]),(void*)&val ) == 0 ){\ found = true;\ @@ -1036,7 +1047,7 @@ GEN_IS_IN_ARRAY_NUM(TYPE_SIZE_T) void extract_name_test_from_name(char *name_org, char **name_f){ size_t len=strlen(name_org); long cur=-1; - char *name_test=malloc(len); + char *name_test=malloc(len+1); for(size_t i=0; inext; - free(ttmp); + if(*fun){ + struct func *tmp = *fun, *ttmp; + while(tmp != NULL){ + free(tmp->name); + ttmp = tmp; + tmp = tmp->next; + free(ttmp); + } + *fun=NULL; + } +} +void +clear_all_falied_list(struct failed_lists **flist) +{ + if(*flist){ + struct failed_lists *tmp = *flist, *ttmp; + while(tmp != NULL){ + free(tmp->name); + + ttmp = tmp; + tmp = tmp->next; + free(ttmp); + } + *flist=NULL; } } /* * to purge func list! * optionnal but good practice */ +void +_purge_t() +{ + + #if 0 + clear_all_func(&f_beging); + clear_all_falied_list(&failed_l); + +#endif + if(array_TYPE_SIZE_T){ + free(array_TYPE_SIZE_T); + array_TYPE_SIZE_T = NULL; + } + if(array_TYPE_STRING) { + for(int i=0; i< cur_array_TYPE_STRING; ++i){ + free(array_TYPE_STRING[i]); + } + free(array_TYPE_STRING); + array_TYPE_STRING = NULL; + } + + PRINT_DEBUG("%s\n","_purge_t done "); +} + + + __attribute__((destructor)) void purge_tests() { - struct func *tmp = f_beging; - clear_all_func(&tmp); + + #if 1 + clear_all_func(&f_beging); + clear_all_falied_list(&failed_l); +#endif + if(array_TYPE_SIZE_T){ + free(array_TYPE_SIZE_T); + } + if(array_TYPE_STRING) { + for(int i=0; i< cur_array_TYPE_STRING; ++i){ + free(array_TYPE_STRING[i]); + } + free(array_TYPE_STRING); + } + PRINT_DEBUG("%s\n","purge done"); } diff --git a/ytools_t/include/tools_t/tools_t.h b/ytools_t/include/tools_t/tools_t.h index 6f20a20..c620156 100644 --- a/ytools_t/include/tools_t/tools_t.h +++ b/ytools_t/include/tools_t/tools_t.h @@ -23,8 +23,6 @@ #define F_ERR stderr #endif - - /* #ifndef SECOND #define SECOND 0 @@ -38,6 +36,14 @@ double diff_timespec_milliseconds(struct timespec time_stop, struct timespec tim long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start); */ +#if 1 + +extern long int PRECISION_TYPE_FLOAT ; +extern long int PRECISION_TYPE_DOUBLE ; +extern long int PRECISION_TYPE_L_DOUBLE ; + +#endif + void gotoxy(int x, int y); //void get_cursor_position(int *col, int *rows); diff --git a/ytools_t/src/tools_t/tools_t.c b/ytools_t/src/tools_t/tools_t.c index 0afbcb2..a073550 100644 --- a/ytools_t/src/tools_t/tools_t.c +++ b/ytools_t/src/tools_t/tools_t.c @@ -1,11 +1,13 @@ #include "tools_t/tools_t.h" + void gotoxy(int x, int y) { printf("%c[%d;%df", 0x1B, y, x); } + /* void get_cursor_position(int *col, int *rows) { @@ -48,9 +50,10 @@ long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_s #define GEN_TO_STR_N(type,size,format) \ TYPE_STRING type##_TO_STR(type var){ \ char *ret = malloc(size); \ - sprintf(ret,format,var); \ - ret[strlen(ret)]='\0'; \ - return ret; } + int szret = sprintf(ret,format,var); \ + ret[szret]='\0'; \ + return ret; \ + }\ GEN_TO_STR_N(TYPE_CHAR,2,"%c") GEN_TO_STR_N(TYPE_U_CHAR,2,"%c") @@ -67,6 +70,8 @@ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){ return var; } +#if 0 + #define PRECISION_TYPE_CHAR 1 #define PRECISION_TYPE_U_CHAR 1 #define PRECISION_TYPE_INT 1 @@ -77,22 +82,44 @@ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){ // with gcc we can change value of theses PRECISION_TYPES below with: gcc -D PRECISION_TYPE_FLOAT=100000 for instance! #ifndef PRECISION_TYPE_FLOAT - /*#define PRECISION_TYPE_FLOAT 100000000*/ - #define PRECISION_TYPE_FLOAT 10 + #define PRECISION_TYPE_FLOAT 100000000 + /*#define PRECISION_TYPE_FLOAT 10*/ #endif #ifndef PRECISION_TYPE_DOUBLE - /*#define PRECISION_TYPE_DOUBLE 100000000000*/ - #define PRECISION_TYPE_DOUBLE 1000 + #define PRECISION_TYPE_DOUBLE 100000000000 + /*#define PRECISION_TYPE_DOUBLE 1000*/ #endif #ifndef PRECISION_TYPE_L_DOUBLE #define PRECISION_TYPE_L_DOUBLE 100000000000000 #endif +#endif + +#if 1 + +long int PRECISION_TYPE_CHAR = 1; +long int PRECISION_TYPE_U_CHAR = 1; +long int PRECISION_TYPE_INT = 1; +long int PRECISION_TYPE_U_INT = 1; +long int PRECISION_TYPE_L_INT = 1; +long int PRECISION_TYPE_U_L_INT = 1; +long int PRECISION_TYPE_SIZE_T = 1; + +long int PRECISION_TYPE_FLOAT = 100000000; +long int PRECISION_TYPE_DOUBLE = 100000000000; +long int PRECISION_TYPE_L_DOUBLE = 100000000000000; + +#endif + + + #define GENERATE_FUNCTION_NUMERIC(type)\ int COMPARE_N_##type(const void *a, const void *b){ \ - type diff = (*(type*)a - *(type*)b)*PRECISION_##type; \ - PRINT_DEBUG_(" diff = %s a=%s b=%s \n",type##_TO_STR(diff),type##_TO_STR(*(type*)a), type##_TO_STR(*(type*)b));\ - if ((diff < 1) && (diff > -1) ) return 0; \ + type diff = (*(type*)a - *(type*)b) * PRECISION_##type; \ + /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\ + PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\ + free(str_diff); free(str_a); free(str_b);\ + */if ((diff < 1) && (diff > -1) ) return 0; \ return diff; \ } \ \