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

add opencl product tensor, update contracted product cl, test precision float and double in tools

Browse Source
This commit is contained in:
fanasina
2024-01-24 19:01:00 +01:00
parent d64e1f0320
commit 4bf32c6501
4 changed files with 303 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tensor_t/src/tensor_t/cl_tensor_t.c
+79 -68
View File
@@ -3,71 +3,16 @@
#define MAX_SOURCE_SIZE (0x100000) #define MAX_SOURCE_SIZE (0x100000)
#define CL_GEN_SETUP_(type,file_cl_src,func_cl_name)\
#define CL_GEN_FUNC_TENSOR(type)\ /* Load the kernel source code into the array source_str*/ \
tensor_##type* CREATE_CL_TENSOR_##type(dimension *dim){\
tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
updateRankDim(dim);\
r_tens->dim = dim;\
r_tens->x = malloc(sizeof(type)*dim->rank);\
return r_tens;\
}\
\
\
void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
tensor_##type *M = *MM; \
size_t m_idx;\
for(size_t i=0; i<M0->dim->rank; ++i){\
for(size_t j=0; j<M1->dim->rank; ++j){\
m_idx= i*M1->dim->rank + j ;\
M->x[m_idx]=M0->x[i]*M1->x[j];\
/*printf("[%ld|%ld:(%ld,%ld)]",x_idx++,m_idx,i,j);*/\
}\
}\
} \
\
/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n / xl = y0,x{l+1}=y1, x{n}=yl et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
\
void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
\
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;\
\
\
/* Load the kernel source code into the array source_str*/ \
FILE *fp; \ FILE *fp; \
char *source_str; \ char *source_str; \
size_t source_size; \ size_t source_size; \
\ \
fp = fopen("/media/fanasina/corsair480/progr_/ytest/y_PROJECT/tensor_t/src/tensor_t/kernel_ProdContractnTensor.cl", "r"); \ /*fp = fopen("../src/kernel_ProdTensor.cl", "r");*/ \
fp = fopen(file_cl_src, "r"); \
if (!fp) { \ if (!fp) { \
perror("kernel_ProdContractnTensor.cl");\ perror(file_cl_src);\
fprintf(stderr, "Failed to load kernel. \n"); \ fprintf(stderr, "Failed to load kernel. \n"); \
exit(1); \ exit(1); \
} \ } \
@@ -118,17 +63,19 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
printf("log: %s \n",log);\ printf("log: %s \n",log);\
\ \
/*/ Create the OpenCL kernel */ \ /*/ Create the OpenCL kernel */ \
char func_cl_name[250]; sprintf(func_cl_name,"prodContractnTensorLin_%s", #type); \ /*char func_cl_name[250]; sprintf(func_cl_name,"prodTensorLin_%s", #type);*/ \
printf("cl_func_type = %s\n",func_cl_name); \ printf("cl_func_type = %s\n",func_cl_name); \
cl_kernel kernel = clCreateKernel(program, func_cl_name, &ret); \ cl_kernel kernel = clCreateKernel(program, func_cl_name, &ret); \
\
/*/ Set the arguments of the kernel */ \ /*/ Set the arguments of the kernel */ \
ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(dSub1->rank)); \ /*ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(M1->dim->rank)); \
ret = clSetKernelArg(kernel, 1, sizeof(size_t), (void *)&(dM->rank)); \ ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&M0_mem_obj); \
ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M0_mem_obj); \ ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M1_mem_obj); \
ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M1_mem_obj); \ ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M_mem_obj); \
ret = clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&M_mem_obj); \ */
\
#define CL_EXEC_KERNEL(type)\
/*/ Execute the OpenCL kernel on the list */ \ /*/ Execute the OpenCL kernel on the list */ \
size_t global_item_size = M->dim->rank; /*/ Process the entire lists */ \ size_t global_item_size = M->dim->rank; /*/ Process the entire lists */ \
size_t local_item_size = 1; /*64;*/ /*/ Divide work items into groups of 64 */ \ size_t local_item_size = 1; /*64;*/ /*/ Divide work items into groups of 64 */ \
@@ -149,8 +96,72 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
ret = clReleaseMemObject(M_mem_obj); \ ret = clReleaseMemObject(M_mem_obj); \
ret = clReleaseCommandQueue(command_queue); \ ret = clReleaseCommandQueue(command_queue); \
ret = clReleaseContext(context); \ ret = clReleaseContext(context); \
#define CL_GEN_FUNC_TENSOR(type)\
\
\
void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) { \
dimension *dd; \
add_dimension(&dd, M0->dim, M1->dim); \
(*MM)=CREATE_TENSOR_##type(dd); \
tensor_##type *M = *MM; \
char *file_cl_src = "../src/kernel_ProdTensor.cl"; \
char *func_cl_name = "prodTensorLin_" #type; \
CL_GEN_SETUP_(type,file_cl_src,func_cl_name);\
/*/ Set the arguments of the kernel */ \
ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(M1->dim->rank)); \
ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&M0_mem_obj); \
ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M1_mem_obj); \
ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M_mem_obj); \
CL_EXEC_KERNEL(type);\
} \
\
/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n / xl = y0,x{l+1}=y1, x{n}=yl et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
\
void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
\
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_ProdContractnTensor.cl"; \
char *func_cl_name = "prodContractnTensorLin_" #type; \
CL_GEN_SETUP_(type,file_cl_src,func_cl_name);\
\
/*/ Set the arguments of the kernel */ \
ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(dSub1->rank)); \
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); \
\
CL_EXEC_KERNEL(type);\
\
} \ } \
CL_GEN_FUNC_TENSOR(TYPE_FLOAT); CL_GEN_FUNC_TENSOR(TYPE_FLOAT);
CL_GEN_FUNC_TENSOR(TYPE_DOUBLE); CL_GEN_FUNC_TENSOR(TYPE_DOUBLE);
tensor_t/test/is_good.c
+219 -38
View File
@@ -85,10 +85,7 @@ TEST(tensorProd ){
print_tensor_float(M,"M"); print_tensor_float(M,"M");
size_t x_idx=0, m_idx; EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
for(size_t i=0; i<M->dim->rank; ++i){
EXPECT_EQ_TYPE_FLOAT(Mn->x[i],M->x[i]);
}
print_tensor_float(Mn,"Mn"); print_tensor_float(Mn,"Mn");
} }
@@ -141,13 +138,13 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
dimension *d0=create_dim(3); dimension *d0=create_dim(3);
dimension *d1=create_dim(3); dimension *d1=create_dim(3);
d0->perm[0]=5; d0->perm[0]=35;
d0->perm[1]=2; //3; d0->perm[1]=32; //3;
d0->perm[2]=3; d0->perm[2]=23;
d1->perm[0]=2; d1->perm[0]=32;
d1->perm[1]=3;//3; d1->perm[1]=23;//3;
d1->perm[2]=4; d1->perm[2]=44;
updateRankDim(d0); updateRankDim(d0);
updateRankDim(d1); updateRankDim(d1);
@@ -161,23 +158,23 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
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.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2; 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(M0,"M0");
print_tensor_float(M1,"M1"); // print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M; tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO; tensor_TYPE_FLOAT *MnO;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2); tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
print_tensor_float(M,"M"); // print_tensor_float(M,"M");
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2); tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
print_tensor_float(MnO,"MnO"); // print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i) // for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]); // EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
} }
@@ -186,13 +183,13 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
dimension *d0=create_dim(3); dimension *d0=create_dim(3);
dimension *d1=create_dim(3); dimension *d1=create_dim(3);
d0->perm[0]=5; d0->perm[0]=35;
d0->perm[1]=2; //3; d0->perm[1]=32; //3;
d0->perm[2]=3; d0->perm[2]=23;
d1->perm[0]=2; d1->perm[0]=32;
d1->perm[1]=3;//3; d1->perm[1]=23;//3;
d1->perm[2]=4; d1->perm[2]=44;
updateRankDim(d0); updateRankDim(d0);
updateRankDim(d1); updateRankDim(d1);
@@ -206,23 +203,23 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
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.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2; 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(M0,"M0");
print_tensor_float(M1,"M1"); // print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M; tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *MnO; tensor_TYPE_FLOAT *MnO;
tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2); tensorContractnProdNotOpt_TYPE_FLOAT(&M, M0,M1,2);
print_tensor_float(M,"M"); // print_tensor_float(M,"M");
cl_tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,2); cl_tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,2);
print_tensor_float(MnO,"MnO"); // print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i) // for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]); // EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank); //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
} }
@@ -231,13 +228,13 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
dimension *d0=create_dim(3); dimension *d0=create_dim(3);
dimension *d1=create_dim(3); dimension *d1=create_dim(3);
d0->perm[0]=5; d0->perm[0]=125;
d0->perm[1]=2; //3; d0->perm[1]=52; //3;
d0->perm[2]=3; d0->perm[2]=63;
d1->perm[0]=2; d1->perm[0]=52;
d1->perm[1]=3;//3; d1->perm[1]=63;//3;
d1->perm[2]=4; d1->perm[2]=54;
updateRankDim(d0); updateRankDim(d0);
updateRankDim(d1); updateRankDim(d1);
@@ -251,18 +248,19 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
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.1 +1;
for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2; 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(M0,"M0");
print_tensor_double(M1,"M1"); //print_tensor_double(M1,"M1");
tensor_TYPE_DOUBLE *M; tensor_TYPE_DOUBLE *M;
tensor_TYPE_DOUBLE *MnO; tensor_TYPE_DOUBLE *MnO;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2); tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
print_tensor_double(M,"M"); //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//print_tensor_double(M,"M");
cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2); cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
print_tensor_double(MnO,"MnO"); //print_tensor_double(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++i) // for(size_t i=0;i<M->dim->rank;++i)
// EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
@@ -271,6 +269,189 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
} }
TEST(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;
d1->perm[0]=52;
d1->perm[1]=63;//3;
d1->perm[2]=54;
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;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//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");
// 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(TensorProdCL){
dimension *d0=create_dim(3);
dimension *d1=create_dim(2);
d0->perm[0]=2;
d0->perm[1]=3;
d0->perm[2]=2;
d1->perm[0]=2;
d1->perm[1]=3;
updateRankDim(d0);
updateRankDim(d1);
tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(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_float(M0,"M0");
print_tensor_float(M1,"M1");
tensor_TYPE_FLOAT *M;
tensor_TYPE_FLOAT *Mn;
tensorProd_TYPE_FLOAT(&M,M0,M1);
cl_tensorProd_TYPE_FLOAT(&Mn,M0,M1);
LOG("M->dim->rank = %ld\n",M->dim->rank);
print_tensor_float(M,"M");
EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
print_tensor_float(Mn,"Mn");
}
TEST(VS_cl_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;
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;
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;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
//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");
// 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);
}
int main(int argc, char **argv){ int main(int argc, char **argv){
ytest_t/libytest.so
BIN
View File
Binary file not shown.
ytools_t/src/tools_t/tools_t.c
+3 -2
View File
@@ -78,10 +78,11 @@ 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! // with gcc we can change value of theses PRECISION_TYPES below with: gcc -D PRECISION_TYPE_FLOAT=100000 for instance!
#ifndef PRECISION_TYPE_FLOAT #ifndef PRECISION_TYPE_FLOAT
/*#define PRECISION_TYPE_FLOAT 100000000*/ /*#define PRECISION_TYPE_FLOAT 100000000*/
#define PRECISION_TYPE_FLOAT 100000 #define PRECISION_TYPE_FLOAT 10
#endif #endif
#ifndef PRECISION_TYPE_DOUBLE #ifndef PRECISION_TYPE_DOUBLE
#define PRECISION_TYPE_DOUBLE 100000000000 /*#define PRECISION_TYPE_DOUBLE 100000000000*/
#define PRECISION_TYPE_DOUBLE 1000
#endif #endif
#ifndef PRECISION_TYPE_L_DOUBLE #ifndef PRECISION_TYPE_L_DOUBLE
#define PRECISION_TYPE_L_DOUBLE 100000000000000 #define PRECISION_TYPE_L_DOUBLE 100000000000000