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

[update] tensor: add more Opt0 contract func thread

Browse Source
This commit is contained in:
fanasina
2026-01-22 22:53:20 +01:00
parent 97d881819d
commit d45bb075cf
3 changed files with 512 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tensor_t/src/tensor_t/tensor_t.c
+207 -9
View File
@@ -788,19 +788,19 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
\
\
\
size_t a0_id, a1_id, n0_id, n1_id, begin0, begin1;\
size_t a0_id, a1_id, n0_id, n1_id;\
for (size_t i = 0; i < M->dim->rank; i++) {\
if(endian){\
a0_id=i/dSub1->rank;\
a1_id=i%dSub1->rank;\
begin0=a0_id*dM->rank ;\
begin1= a1_id ;\
n0_id=a0_id*dM->rank ;\
n1_id= a1_id ;\
}\
else{\
a0_id=i%dSub0->rank;\
a1_id=i/dSub0->rank;\
begin1= a1_id*dM->rank ;\
begin0= a0_id ;\
n1_id= a1_id*dM->rank ;\
n0_id= a0_id ;\
}\
M->x[i] = 0;\
for (size_t k = 0; k < dM->rank; k++) {\
@@ -808,15 +808,15 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
/*n0_id= a0_id*dM->rank + k;*/\
/*n1_id= a1_id + dSub1->rank * k;*/\
/*M->x[i] += M0->x[begin0++] * M1->x[n1_id];*/\
M->x[i] += M0->x[begin0++] * M1->x[begin1];\
begin1 +=dSub1->rank ;\
M->x[i] += M0->x[n0_id++] * M1->x[n1_id];\
n1_id +=dSub1->rank ;\
}\
else{\
/*n0_id= a0_id + dSub0->rank * k;*/\
/*n1_id= a1_id*dM->rank + k;*/\
/*M->x[i] += M0->x[n0_id] * M1->x[begin1++];*/\
M->x[i] += M0->x[begin0] * M1->x[begin1++];\
begin0 += dSub0->rank ;\
M->x[i] += M0->x[n0_id] * M1->x[n1_id++];\
n0_id += dSub0->rank ;\
}\
\
}\
@@ -1051,6 +1051,103 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
FREE_dM_S_ ; \
}\
\
\
void* runProdContractOpt0_thread_##type(void *arg){\
struct arg_ProdContract_##type *arg_t = arg;\
size_t a0_id, a1_id, n0_id, n1_id;\
for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
if(endian){\
a0_id=i/ arg_t->dSubRank;\
a1_id=i% arg_t->dSubRank;\
n0_id= a0_id * arg_t->dMRank ;\
n1_id= a1_id ;\
}\
else{\
a0_id=i% arg_t->dSubRank;\
a1_id=i/ arg_t->dSubRank;\
n0_id= a0_id ;\
n1_id= a1_id * arg_t->dMRank ;\
}\
arg_t->Mx[i] = 0;\
for (size_t k = 0; k < arg_t->dMRank; k++) {\
if(endian){\
arg_t->Mx[i] += arg_t->M0x[n0_id++] * arg_t->M1x[n1_id];\
n1_id += arg_t->dSubRank ;\
}\
else{\
arg_t->Mx[i] += arg_t->M0x[n0_id] * arg_t->M1x[n1_id];\
n0_id += arg_t->dSubRank ;\
}\
}\
}\
return 0;\
}\
\
\
void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
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_copy_dimension(&dM, dM0, dM1);\
\
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
\
\
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_ProdContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_ProdContract_##type *));\
\
for(size_t i = 0; i < nbthread; ++i){\
arg_th[i]=malloc(sizeof(struct arg_ProdContract_##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]->dSubRank = dSub1->rank;\
}\
else{\
arg_th[i]->dSubRank = dSub0->rank;\
}\
arg_th[i]->dMRank = dM->rank;\
pthread_create(&thrd[i], NULL, runProdContractOpt0_thread_##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);\
FREE_dM_S_ ; \
}\
\
struct arg_Pro2dContract_##type{\
type *M0x;\
type *M1x;\
@@ -1061,6 +1158,7 @@ struct arg_Pro2dContract_##type{\
size_t dSub0Rank;\
size_t dSub1Rank;\
};\
\
void* runPro2dContract_thread_##type(void *arg){\
struct arg_Pro2dContract_##type *arg_t = arg;\
size_t n0_id, n1_id, l;\
@@ -1152,6 +1250,106 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
free(arg_th);\
FREE_dM_S_ ; \
}\
\
void* runPro2dContractOpt0_thread_##type(void *arg){\
struct arg_Pro2dContract_##type *arg_t = arg;\
size_t n0_id, n1_id, l;\
for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
for (size_t j = 0; j < arg_t->dSub1Rank; j++) {\
if(endian){\
l = j + arg_t->dSub1Rank * i;\
n0_id= i * arg_t->dMRank ;\
n1_id= j ;\
}else{\
l = j * arg_t->dSub0Rank + i;\
n0_id= i ;\
n1_id= j * arg_t->dMRank ;\
}\
arg_t->Mx[l] = 0;\
for (size_t k = 0; k < arg_t->dMRank; k++) {\
if(endian){\
/*n0_id= i * arg_t->dMRank + k;\
n1_id= j + arg_t->dSub1Rank * k;*/\
arg_t->Mx[l] += arg_t->M0x[n0_id++] * arg_t->M1x[n1_id];\
n1_id += arg_t->dSub1Rank ;\
}\
else{\
/*n0_id= i + arg_t->dSub0Rank * k;\
n1_id= j * arg_t->dMRank + k;*/\
arg_t->Mx[l] += arg_t->M0x[n0_id] * arg_t->M1x[n1_id];\
n0_id += arg_t->dSub0Rank ;\
}\
}\
}\
}\
return 0;\
}\
/* 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 tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
/*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
}*/\
if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
printDebug_dimension(M0->dim, "M0 dim");\
printDebug_dimension(M1->dim, "M1 dim");\
getchar();\
}\
\
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_copy_dimension(&dM, dM0, dM1);\
\
dimension *dd;\
add_dimension(&dd, dSub0, dSub1);\
updateRankDim(dd);\
_RECREATE_TENSOR_IF_NOT_THE_SAME_DIM_OR_NULL_##type(MM,dd);\
tensor_##type *M= *MM;\
\
\
\
pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
struct arg_Pro2dContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2dContract_##type *));\
\
for(size_t i = 0; i < nbthread; ++i) {\
arg_th[i] = malloc(sizeof(struct arg_Pro2dContract_##type));\
arg_th[i]->M0x=M0->x;\
arg_th[i]->M1x=M1->x;\
arg_th[i]->Mx=M->x;\
arg_th[i]->beginRange = i*(dSub0->rank)/nbthread ;\
arg_th[i]->endRange = (i+1)*(dSub0->rank)/nbthread ;\
arg_th[i]->dSub1Rank = dSub1->rank;\
arg_th[i]->dSub0Rank = dSub0->rank;\
arg_th[i]->dMRank = dM->rank;\
pthread_create(&thrd[i], NULL, runPro2dContractOpt0_thread_##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);\
FREE_dM_S_ ; \
}\
void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
if (!checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)) {\
printf("error Deep = %ld\n", contractionNumber);\
tensor_t/src/tensor_t/tensor_t.h
+2
View File
@@ -40,7 +40,9 @@ void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##
void tensorProdThread_##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 tensorContractnProdThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
void tensorContractnPro2dThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
void tensorContractnPro2dThreadOpt0_##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); \
void tensorContractnProdOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
type scalarProduct_dep_contractProd_##type(tensor_##type *M0, tensor_##type *M1, size_t nbthreads ,void (*tensorContractVar)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread ));\
tensor_t/test/is_good.c
+303
View File
@@ -1204,6 +1204,309 @@ TEST(tensorContractnProdOpt0_TYPE_FLOAT2 ){
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProdThreadOpt0_TYPE_FLOAT2 ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
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]=335;
d0->perm[1]=32; //3;
d0->perm[2]=43;
d1->perm[0]=32;
d1->perm[1]=43;//3;
d1->perm[2]=244;
#endif
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=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProdThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
// print_tensor_float(M,"M");
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
// print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++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);
free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnPro2dThreadOpt0_TYPE_FLOAT2 ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
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]=335;
d0->perm[1]=32; //3;
d0->perm[2]=43;
d1->perm[0]=32;
d1->perm[1]=43;//3;
d1->perm[2]=244;
#endif
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=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnPro2dThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
// print_tensor_float(M,"M");
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
// print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++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);
free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnPro2dThread_TYPE_FLOAT2 ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
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]=335;
d0->perm[1]=32; //3;
d0->perm[2]=43;
d1->perm[0]=32;
d1->perm[1]=43;//3;
d1->perm[2]=244;
#endif
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=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnPro2dThread_TYPE_FLOAT(&M, M0,M1,2,8);
// print_tensor_float(M,"M");
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
// print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++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);
free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProdThread_TYPE_FLOAT2 ){
dimension *d0=create_dim(3);
dimension *d1=create_dim(3);
#if VALGRIND_
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]=335;
d0->perm[1]=32; //3;
d0->perm[2]=43;
d1->perm[0]=32;
d1->perm[1]=43;//3;
d1->perm[2]=244;
#endif
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=NULL;
tensor_TYPE_FLOAT *MnO=NULL;
tensorContractnProdThread_TYPE_FLOAT(&M, M0,M1,2,8);
// print_tensor_float(M,"M");
tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
// print_tensor_float(MnO,"MnO");
// for(size_t i=0;i<M->dim->rank;++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);
free_tensor_TYPE_FLOAT(M);
free_tensor_TYPE_FLOAT(MnO);
free_tensor_TYPE_FLOAT(M0);
free_tensor_TYPE_FLOAT(M1);
}
TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
dimension *d0=create_dim(2);
dimension *d1=create_dim(1);
#if VALGRIND_
d0->perm[0]=4;
d0->perm[1]=2; //3;
d1->perm[0]=2;
#else
d0->perm[0]=125;
d0->perm[1]=52; //3;
d1->perm[0]=52;
#endif
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=NULL;
tensor_TYPE_DOUBLE *MnO=NULL;
tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
//print_tensor_double(M,"M");
//cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,1);
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(tensorContractnProd_TYPE_DOUBLE_2_1 ){
dimension *d0=create_dim(2);
dimension *d1=create_dim(1);