fanasina/y_project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

debug all leak mem with valgrind in ftest and tensor rep

Browse Source
This commit is contained in:
fanasina
2024-02-08 23:57:10 +01:00
parent 6ae0f7cd75
commit e1171d720b
32 changed files with 1468 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+2
View File
@@ -7,3 +7,5 @@ log*
*/**/**.o
launch_*
eEcomp
*massif*
*xtmemory*
dimension_t/src/dimension_t/dimension_t.c
+70 -2
View File
@@ -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);
dimension_t/src/dimension_t/dimension_t.h
+10
View File
@@ -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);
tensor_t/src/kernel_2d_ProdContractnTensor.cl
+60 -21
View File
@@ -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];
}
}
tensor_t/src/kernel_2d_ProdTensor.cl
+1 -7
View File
@@ -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];
}
tensor_t/src/kernel_ProdContractnTensor.cl
-7
View File
@@ -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];
}
}
tensor_t/src/kernel_ProdTensor.cl
-5
View File
@@ -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];
}
tensor_t/src/tensor_t/cl_tensor_t.c
+67 -3
View File
@@ -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) {
tensor_t/src/tensor_t/cl_tensor_t.h
+1 -1
View File
@@ -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);
tensor_t/src/tensor_t/tensor_t.c
+217 -76
View File
@@ -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; i<dS_h->rank; ++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; i<dS_h->rank; ++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; i<dS_t->rank; ++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; i<dS_t->rank; ++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; i<dS_h->rank; ++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; i<dS_h->rank; ++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; i<dS_t->rank; ++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; i<dS_t->rank; ++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; i<dS_h->rank; ++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; i<dS_h->rank; ++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; i<dS_t->rank; ++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; i<dS_t->rank; ++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; i<dS_h->rank; ++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; i<dS_h->rank; ++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; i<dS_t->rank; ++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; i<dS_t->rank; ++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_ ; \
}\
\
tensor_t/src/tensor_t/tensor_t.h
+7 -2
View File
@@ -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); \
tensor_t/test/Makefile
+1 -1
View File
@@ -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
tensor_t/test/is_good.c
+217 -51
View File
@@ -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; i<M->dim->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; i<M->dim->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; i<M0->dim->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; i<M0->dim->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; i<M0->dim->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; i<M0->dim->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; i<M1->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.01 +1;
for(size_t i=0; i<M1->dim->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){
tensor_t/test_cl/Makefile
+5 -1
View File
@@ -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
tensor_t/test_cl/is_good.c
+316 -64
View File
@@ -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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;i<M->dim->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;i<M->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;i<M->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;i<M->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;i<M->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;i<M->dim->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; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
for(size_t i=0; i<M1->dim->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;
ypermutation_t/src/permutation_t/permutation_t.c
+12 -3
View File
@@ -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;i<size;++i) p->perm[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;i<size;++i) p->perm[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;\
}\
\
ypermutation_t/src/permutation_t/permutation_t.h
+1
View File
@@ -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);\
ypermutation_t/test/is_good.c
+13 -6
View File
@@ -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; i<p_char->size; ++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
ytest_t/Makefile
+1 -1
View File
@@ -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
ytest_t/example/compile.sh
+1 -1
View File
@@ -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
ytest_t/example/eg1.c
+26 -4
View File
@@ -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);
ytest_t/example/x1
BIN
View File
Binary file not shown.
ytest_t/include_ytest/include/ftest/ftest.h
+63 -23
View File
@@ -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; \
} \
ytest_t/include_ytest/include/ftest/ftest_array.h
+72 -30
View File
@@ -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; \
} \
ytest_t/include_ytest/include/tools_t/tools_t.h
+8 -2
View File
@@ -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);
ytest_t/libytest.so
BIN
View File
Binary file not shown.
ytest_t/test/is_good.c
+9 -3
View File
@@ -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){
ytest_t/yftest/include/ftest/ftest.h
+63 -23
View File
@@ -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; \
} \
ytest_t/yftest/include/ftest/ftest_array.h
+72 -30
View File
@@ -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; \
} \
ytest_t/yftest/src/ftest/ftest.c
+108 -26
View File
@@ -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;i<sz1;++i){\
if(COMPARE_N_##type(&var1[i], &var2[i]) OP 0)\
++count;\
/*if(COMPARE_N_##type((void*)&var1[i],(void*)&var2[i]) OP 0)\
*/if(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)\
++count_;\
else{ \
INCREMENT(count_fail_local); /*++count_fail_local*/ \
return false;\
}\
}\
if(count==sz1){ \
if(count_ == sz1){ \
INCREMENT(count_pass_local); /*++count_pass_local*/ \
return true; \
}\
@@ -761,17 +766,17 @@ bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int
} \
bool expected_array_##OP##_name_##type(type *var1, long int sz1, type *var2, long int sz2, const char * name){ \
if(sz1 OP sz2){\
size_t count=0;\
if(sz1 == sz2){\
size_t count_=0;\
for(size_t i=0;i<sz1;++i){\
if(COMPARE_N_##type(&var1[i], &var2[i]) OP 0)\
++count;\
if(COMPARE_N_##type((void*)&var1[i], (void*)&var2[i]) OP 0)\
++count_;\
else {\
INCREMENT_EXPECT(fail,name);\
return false;\
}\
}\
if(count==sz1){ \
if(count_ == sz1){ \
INCREMENT_EXPECT(pass,name);\
return true; \
}\
@@ -922,7 +927,7 @@ append_func(void (*run)(void), char *name){
if(f_beging == NULL){
f_beging = malloc(sizeof(struct func));
f_static = f_beging;
f_static->name = 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; i<len; ++i){
if(cur == -1 && name_org[i]=='(')
cur=0;
@@ -1092,6 +1103,7 @@ void execute_all(struct func *fun){
current_fn = tmp;
}
void _purge_t();
void
run_all_tests()
@@ -1111,6 +1123,9 @@ run_all_tests()
if(progress) pthread_join(thrd_progress, NULL);
#if 0
_purge_t();
#endif
}
/*
@@ -1321,6 +1336,9 @@ final_parallel_test_()
free(count_pass_thread);
free(count_fail_thread);
for(size_t i=0; i< parallel_nb; ++i)
clear_all_falied_list(&thread_test_failed_l[i]);
free(thread_test_failed_l);
@@ -1364,8 +1382,11 @@ final_parallel_test_()
for(size_t i=0; i<=parallel_nb; ++i){
remove(log_name_file_thrd[i]);
PRINT_DEBUG("file log of treard[%ld] removed\n",i);
free(log_name_file_thrd[i]);
}
free(log_name_file_thrd);
}
}
@@ -1406,6 +1427,10 @@ if(progress) pthread_join(thrd_progress, NULL);
free(thrd);
final_parallel_test_();
#if 0
_purge_t();
#endif
}
void run_all_tests_args(int argc, char **argv){
@@ -1417,27 +1442,84 @@ void run_all_tests_args(int argc, char **argv){
if(is_parallel_nb) run_all_tests_parallel(parallel_nb);
else run_all_tests();
}
void
clear_all_func(struct func **fun)
{
struct func *tmp = *fun, *ttmp;
while(tmp != NULL){
ttmp = tmp;
tmp = tmp->next;
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");
}
ytools_t/include/tools_t/tools_t.h
+8 -2
View File
@@ -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);
ytools_t/src/tools_t/tools_t.c
+37 -10
View File
@@ -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; \
} \
\