From d45bb075cf4acb0fcf655fc9005d3fb736128c06 Mon Sep 17 00:00:00 2001 From: fanasina Date: Thu, 22 Jan 2026 22:53:20 +0100 Subject: [PATCH] [update] tensor: add more Opt0 contract func thread --- tensor_t/src/tensor_t/tensor_t.c | 216 +++++++++++++++++++++- tensor_t/src/tensor_t/tensor_t.h | 2 + tensor_t/test/is_good.c | 303 +++++++++++++++++++++++++++++++ 3 files changed, 512 insertions(+), 9 deletions(-) diff --git a/tensor_t/src/tensor_t/tensor_t.c b/tensor_t/src/tensor_t/tensor_t.c index cfe48b0..5abd031 100644 --- a/tensor_t/src/tensor_t/tensor_t.c +++ b/tensor_t/src/tensor_t/tensor_t.c @@ -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<...=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);\ diff --git a/tensor_t/src/tensor_t/tensor_t.h b/tensor_t/src/tensor_t/tensor_t.h index 97d3ab3..8fb2afc 100644 --- a/tensor_t/src/tensor_t/tensor_t.h +++ b/tensor_t/src/tensor_t/tensor_t.h @@ -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 ));\ diff --git a/tensor_t/test/is_good.c b/tensor_t/test/is_good.c index 0c241f4..4071c0a 100644 --- a/tensor_t/test/is_good.c +++ b/tensor_t/test/is_good.c @@ -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; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + +// print_tensor_float(M0,"M0"); +// print_tensor_float(M1,"M1"); + + tensor_TYPE_FLOAT *M=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;idim->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; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + +// print_tensor_float(M0,"M0"); +// print_tensor_float(M1,"M1"); + + tensor_TYPE_FLOAT *M=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;idim->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; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + +// print_tensor_float(M0,"M0"); +// print_tensor_float(M1,"M1"); + + tensor_TYPE_FLOAT *M=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;idim->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; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + +// print_tensor_float(M0,"M0"); +// print_tensor_float(M1,"M1"); + + tensor_TYPE_FLOAT *M=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;idim->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; idim->rank;++i) M0->x[i]=i*0.1 +1; + for(size_t i=0; idim->rank;++i) M1->x[i]=i*0.003 + 2; + + print_tensor_double(M0,"M0"); + print_tensor_double(M1,"M1"); + + tensor_TYPE_DOUBLE *M=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;idim->rank;++i) + // EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]); + + EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank); + + free_tensor_TYPE_DOUBLE(M); + free_tensor_TYPE_DOUBLE(MnO); + free_tensor_TYPE_DOUBLE(M0); + free_tensor_TYPE_DOUBLE(M1); + +} + + + TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){ dimension *d0=create_dim(2); dimension *d1=create_dim(1);