Initial input for backend selection

cpp/daal/include/services/daal_defines.h

@@ -491,13 +491,30 @@ const int SERIALIZATION_DBSCAN_DISTRIBUTED_PARTIAL_RESULT_STEP13_ID = 121310;
         }                                                                                         \
     }
 
+#define DAAL_OVERFLOW_CHECK_BY_MULTIPLICATION_THROW_IF_POSSIBLE(type, op1, op2)                                       \
+    {                                                                                                                 \
+        if (!(0 == (op1)) && !(0 == (op2)))                                                                           \
+        {                                                                                                             \
+            volatile type r = (op1) * (op2);                                                                          \
+            r /= (op1);                                                                                               \
+            if (!(r == (op2))) services::throwIfPossible(services::Status(services::ErrorBufferSizeIntegerOverflow)); \
+        }                                                                                                             \
+    }
+
 #define DAAL_OVERFLOW_CHECK_BY_ADDING(type, op1, op2)                                         \
     {                                                                                         \
         volatile type r = (op1) + (op2);                                                      \
         r -= (op1);                                                                           \
         if (!(r == (op2))) return services::Status(services::ErrorBufferSizeIntegerOverflow); \
     }
 
+#define DAAL_OVERFLOW_CHECK_BY_ADDING_THROW_IF_POSSIBLE(type, op1, op2)                                           \
+    {                                                                                                             \
+        volatile type r = (op1) + (op2);                                                                          \
+        r -= (op1);                                                                                               \
+        if (!(r == (op2))) services::throwIfPossible(services::Status(services::ErrorBufferSizeIntegerOverflow)); \
+    }
+
 #define DAAL_CHECK_STATUS_RETURN_IF_FAIL(statVal, returnObj) \
     {                                                        \
         if (!(statVal)) return returnObj;                    \

cpp/daal/src/algorithms/adaboost/adaboost_predict_impl.i

@@ -146,7 +146,7 @@ services::Status AdaBoostPredictKernel<method, algorithmFPType, cpu>::processBlo
         }
     }
 
-    Math<algorithmFPType, cpu>::vLog(nRowsInCurrentBlock * nClasses, p_block, pLog); // inplace
+    MathInst<algorithmFPType, cpu>::vLog(nRowsInCurrentBlock * nClasses, p_block, pLog); // inplace
 
     service_memset<algorithmFPType, cpu>(pSumLog, 0.0, nRowsInCurrentBlock);
 

cpp/daal/src/algorithms/adaboost/adaboost_train_impl.i

@@ -181,14 +181,14 @@ services::Status AdaBoostTrainKernel<method, algorithmFPType, cpu>::adaboostSAMM
         }
 
         algorithmFPType cM =
-            learningRate * (Math<algorithmFPType, cpu>::sLog((one - errM) / errM) + Math<algorithmFPType, cpu>::sLog(nClasses - one));
+            learningRate * (MathInst<algorithmFPType, cpu>::sLog((one - errM) / errM) + MathInst<algorithmFPType, cpu>::sLog(nClasses - one));
 
         /* Update weights */
         for (size_t i = 0; i < nVectors; i++)
         {
             errFlag[i] *= cM;
         }
-        Math<algorithmFPType, cpu>::vExp(nVectors, errFlag, errFlag);
+        MathInst<algorithmFPType, cpu>::vExp(nVectors, errFlag, errFlag);
         algorithmFPType wSum = zero;
         for (size_t i = 0; i < nVectors; i++)
         {
@@ -337,7 +337,7 @@ services::Status AdaBoostTrainKernel<method, algorithmFPType, cpu>::adaboostSAMM
             }
             t[i] *= scaling;
         }
-        Math<algorithmFPType, cpu>::vExp(nVectors, t, t);
+        MathInst<algorithmFPType, cpu>::vExp(nVectors, t, t);
         for (size_t i = 0; i < nVectors; i++)
         {
             w[i] *= t[i];

cpp/daal/src/algorithms/assocrules/assoc_rules_apriori_impl.i

@@ -70,7 +70,7 @@ Status AssociationRulesKernel<apriori, algorithmFPType, cpu>::compute(const Nume
     /* Find "large" itemsets */
     size_t L_size         = 0;
     size_t maxItemsetSize = ((parameter->maxItemsetSize == 0) ? (size_t)-1 : parameter->maxItemsetSize);
-    double ceil           = daal::internal::Math<double, cpu>::sCeil(minSupport * data.numOfTransactions);
+    double ceil           = daal::internal::MathInst<double, cpu>::sCeil(minSupport * data.numOfTransactions);
     DAAL_ASSERT(ceil >= 0)
     services::Status statLargeItemset = findLargeItemsets((size_t)ceil, maxItemsetSize, data, L.get(), L_size);
     DAAL_CHECK_STATUS_OK(statLargeItemset.ok(), statLargeItemset);

cpp/daal/src/algorithms/assocrules/assoc_rules_apriori_types.i

@@ -249,7 +249,7 @@ struct assocrules_dataset
             supportVals[itemID[i]]++;
         }
         numOfUniqueItems = 0;
-        double ceil      = daal::internal::Math<double, cpu>::sCeil(minSupport * numOfTransactions);
+        double ceil      = daal::internal::MathInst<double, cpu>::sCeil(minSupport * numOfTransactions);
         DAAL_ASSERT(ceil >= 0)
 
         size_t iMinSupport = (size_t)ceil;

cpp/daal/src/algorithms/brownboost/brownboost_predict_impl.i

@@ -116,14 +116,14 @@ services::Status BrownBoostPredictKernel<method, algorithmFPType, cpu>::compute(
     const algorithmFPType zero  = (algorithmFPType)0.0;
     if (error != zero)
     {
-        algorithmFPType sqrtC    = daal::internal::Math<algorithmFPType, cpu>::sErfInv(algorithmFPType(1.0) - error);
+        algorithmFPType sqrtC    = daal::internal::MathInst<algorithmFPType, cpu>::sErfInv(algorithmFPType(1.0) - error);
         algorithmFPType invSqrtC = algorithmFPType(1.0) / sqrtC;
         for (size_t j = 0; j < nVectors; j++)
         {
             r[j] *= invSqrtC;
         }
     }
-    daal::internal::Math<algorithmFPType, cpu>::vErf(nVectors, r, r);
+    daal::internal::MathInst<algorithmFPType, cpu>::vErf(nVectors, r, r);
     return s;
 }
 

cpp/daal/src/algorithms/brownboost/brownboost_train_impl.i

@@ -254,8 +254,8 @@ void BrownBoostTrainKernel<method, algorithmFPType, cpu>::updateWeights(size_t n
         nre2[j] = nra[j] * invSqrtC;
         w[j]    = -nra[j] * nra[j] / c;
     }
-    daal::internal::Math<algorithmFPType, cpu>::vExp(nVectors, w, w);
-    daal::internal::Math<algorithmFPType, cpu>::vErf(nVectors, nre2, nre2);
+    daal::internal::MathInst<algorithmFPType, cpu>::vExp(nVectors, w, w);
+    daal::internal::MathInst<algorithmFPType, cpu>::vErf(nVectors, nre2, nre2);
     algorithmFPType wSum = (algorithmFPType)0.0;
     for (size_t j = 0; j < nVectors; j++)
     {
@@ -309,11 +309,11 @@ NewtonRaphsonKernel<method, algorithmFPType, cpu>::NewtonRaphsonKernel(size_t nV
 {
     const algorithmFPType one = (algorithmFPType)1.0;
     const algorithmFPType pi  = (algorithmFPType)3.1415926535897932384626433832795;
-    sqrtC                     = daal::internal::Math<algorithmFPType, cpu>::sErfInv(one - error);
+    sqrtC                     = daal::internal::MathInst<algorithmFPType, cpu>::sErfInv(one - error);
     c                         = sqrtC * sqrtC;
     invC                      = one / c;
     invSqrtC                  = one / sqrtC;
-    sqrtPiC                   = daal::internal::Math<algorithmFPType, cpu>::sSqrt(pi * c);
+    sqrtPiC                   = daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(pi * c);
 }
 
 template <Method method, typename algorithmFPType, CpuType cpu>
@@ -360,8 +360,8 @@ void NewtonRaphsonKernel<method, algorithmFPType, cpu>::compute(algorithmFPType
             nrw[j]  = -invC * nrd[j] * nrd[j];
             nre1[j] = nrd[j] * invSqrtC;
         }
-        daal::internal::Math<algorithmFPType, cpu>::vExp(nVectors, nrw, nrw);
-        daal::internal::Math<algorithmFPType, cpu>::vErf(nVectors, nre1, nre1);
+        daal::internal::MathInst<algorithmFPType, cpu>::vExp(nVectors, nrw, nrw);
+        daal::internal::MathInst<algorithmFPType, cpu>::vErf(nVectors, nre1, nre1);
         algorithmFPType nrW(0.0);
         algorithmFPType nrU(0.0);
         algorithmFPType nrB(0.0);
@@ -383,9 +383,9 @@ void NewtonRaphsonKernel<method, algorithmFPType, cpu>::compute(algorithmFPType
         nrAlpha += invDenom * (c * nrW * nrB + sqrtPiC * nrU * nrE);
         nrT += invDenom * (c * nrB * nrB + sqrtPiC * nrV * nrE);
 
-        if ((daal::internal::Math<algorithmFPType, cpu>::sFabs(nrB / nrW) <= nu)
-            || (daal::internal::Math<algorithmFPType, cpu>::sFabs(nrB) <= nrAccuracy
-                && daal::internal::Math<algorithmFPType, cpu>::sFabs(nrE) <= nrAccuracy))
+        if ((daal::internal::MathInst<algorithmFPType, cpu>::sFabs(nrB / nrW) <= nu)
+            || (daal::internal::MathInst<algorithmFPType, cpu>::sFabs(nrB) <= nrAccuracy
+                && daal::internal::MathInst<algorithmFPType, cpu>::sFabs(nrE) <= nrAccuracy))
             break;
     }
     nrAlpha *= alphaSign;

cpp/daal/src/algorithms/cholesky/cholesky_impl.i

@@ -108,11 +108,11 @@ Status CholeskyKernel<algorithmFPType, method, cpu>::performCholesky(NumericTabl
 
     if (isFull<algorithmFPType, cpu>(rLayout))
     {
-        Lapack<algorithmFPType, cpu>::xpotrf(&uplo, &dims, pL, &dims, &info);
+        LapackInst<algorithmFPType, cpu>::xpotrf(&uplo, &dims, pL, &dims, &info);
     }
     else if (rLayout == NumericTableIface::lowerPackedTriangularMatrix)
     {
-        Lapack<algorithmFPType, cpu>::xpptrf(&uplo, &dims, pL, &info);
+        LapackInst<algorithmFPType, cpu>::xpptrf(&uplo, &dims, pL, &info);
     }
     else
     {

cpp/daal/src/algorithms/cordistance/cordistance_full_impl.i

@@ -85,7 +85,7 @@ services::Status corDistanceFull(const NumericTable * xTable, NumericTable * rTa
         DAAL_INT m = blockSize1, k = 1, nn = blockSize1;
         DAAL_INT lda = m, ldb = nn, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
 
         /* calculate x * x^t - 1/p * sum^t * sum */
         alpha  = one;
@@ -95,14 +95,14 @@ services::Status corDistanceFull(const NumericTable * xTable, NumericTable * rTa
         m = blockSize1, k = p, nn = blockSize1;
         lda = k, ldb = k, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
 
         PRAGMA_VECTOR_ALWAYS
         for (size_t i = 0; i < blockSize1; i++)
         {
             if (buf[i * blockSize1 + i] > (algorithmFPType)0.0)
             {
-                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::Math<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
+                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
             }
         }
 
@@ -212,7 +212,7 @@ services::Status corDistanceFull(const NumericTable * xTable, NumericTable * rTa
             DAAL_INT m = blockSize2, k = 1, nn = blockSize1;
             DAAL_INT lda = m, ldb = nn, ldc = m;
 
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
 
             /* calculate x1 * x2^t - 1/p * sum1^t * sum2 */
             alpha  = one;
@@ -226,7 +226,7 @@ services::Status corDistanceFull(const NumericTable * xTable, NumericTable * rTa
             ldb    = k;
             ldc    = m;
 
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
 
             for (size_t i = 0; i < blockSize1; i++)
             {

cpp/daal/src/algorithms/cordistance/cordistance_lp_impl.i

@@ -81,7 +81,7 @@ services::Status corDistanceLowerPacked(const NumericTable * xTable, NumericTabl
         DAAL_INT m = blockSize1, k = 1, nn = blockSize1;
         DAAL_INT lda = m, ldb = nn, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
 
         /* calculate x * x^t - 1/p * sum^t * sum */
         alpha  = one;
@@ -93,15 +93,15 @@ services::Status corDistanceLowerPacked(const NumericTable * xTable, NumericTabl
         ldb = k;
         ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
 
         /* compute inverse of sqrt of gemm result and save for use in computation off-diagonal blocks */
         PRAGMA_VECTOR_ALWAYS
         for (size_t i = 0; i < blockSize1; i++)
         {
             if (buf[i * blockSize1 + i] > (algorithmFPType)0.0)
             {
-                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::Math<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
+                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
             }
         }
 
@@ -226,7 +226,7 @@ services::Status corDistanceLowerPacked(const NumericTable * xTable, NumericTabl
             DAAL_INT m = blockSize2, k = 1, nn = blockSize1;
             DAAL_INT lda = m, ldb = nn, ldc = m;
 
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
 
             /* calculate x1 * x2^t - 1/p * sum1^t * sum2 */
             alpha  = one;
@@ -241,7 +241,7 @@ services::Status corDistanceLowerPacked(const NumericTable * xTable, NumericTabl
             ldc    = m;
 
             /* compute the distance between k1 and k2 blocks of rows in the input dataset */
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
 
             for (size_t i = 0; i < blockSize1; i++)
             {

cpp/daal/src/algorithms/cordistance/cordistance_up_impl.i

@@ -81,7 +81,7 @@ services::Status corDistanceUpperPacked(const NumericTable * xTable, NumericTabl
         DAAL_INT m = blockSize1, k = 1, nn = blockSize1;
         DAAL_INT lda = m, ldb = nn, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum, &lda, sum, &ldb, &beta, buf, &ldc);
 
         /* calculate x * x^t - 1/p * sum^t * sum */
         alpha  = one;
@@ -93,15 +93,15 @@ services::Status corDistanceUpperPacked(const NumericTable * xTable, NumericTabl
         ldb = k;
         ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
 
         /* compute inverse of sqrt of gemm result and save for use in computation off-diagonal blocks */
         PRAGMA_VECTOR_ALWAYS
         for (size_t i = 0; i < blockSize1; i++)
         {
             if (buf[i * blockSize1 + i] > (algorithmFPType)0.0)
             {
-                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::Math<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
+                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
             }
         }
 
@@ -225,7 +225,7 @@ services::Status corDistanceUpperPacked(const NumericTable * xTable, NumericTabl
             DAAL_INT m = blockSize2, k = 1, nn = blockSize1;
             DAAL_INT lda = m, ldb = nn, ldc = m;
 
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, sum2, &lda, sum1l, &ldb, &beta, buf, &ldc);
 
             /* calculate x1 * x2^t - 1/p * sum1^t * sum2 */
             alpha  = one;
@@ -240,7 +240,7 @@ services::Status corDistanceUpperPacked(const NumericTable * xTable, NumericTabl
             ldc    = m;
 
             /* compute the distance between k1 and k2 blocks of rows in the input dataset */
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
 
             for (size_t i = 0; i < blockSize1; i++)
             {

cpp/daal/src/algorithms/cosdistance/cosdistance_full_impl.i

@@ -69,14 +69,14 @@ services::Status cosDistanceFull(const NumericTable * xTable, NumericTable * rTa
         DAAL_INT m = blockSize1, k = p, nn = blockSize1;
         DAAL_INT lda = k, ldb = p, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
 
         PRAGMA_VECTOR_ALWAYS
         for (size_t i = 0; i < blockSize1; i++)
         {
             if (buf[i * blockSize1 + i] > (algorithmFPType)0.0)
             {
-                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::Math<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
+                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
             }
         }
 
@@ -154,7 +154,7 @@ services::Status cosDistanceFull(const NumericTable * xTable, NumericTable * rTa
             DAAL_INT m = blockSize2, k = p, nn = blockSize1;
             DAAL_INT lda = k, ldb = p, ldc = m;
 
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
 
             for (size_t i = 0; i < blockSize1; i++)
             {

cpp/daal/src/algorithms/cosdistance/cosdistance_lp_impl.i

@@ -65,15 +65,15 @@ services::Status cosDistanceLowerPacked(const NumericTable * xTable, NumericTabl
         DAAL_INT m = blockSize1, k = p, nn = blockSize1;
         DAAL_INT lda = k, ldb = p, ldc = m;
 
-        Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
+        BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x, &lda, x, &ldb, &beta, buf, &ldc);
 
         /* compute inverse of sqrt of gemm result and save for use in computation off-diagonal blocks */
         PRAGMA_VECTOR_ALWAYS
         for (DAAL_INT i = 0; i < blockSize1; i++)
         {
             if (buf[i * blockSize1 + i] > (algorithmFPType)0.0)
             {
-                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::Math<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
+                buf[i * blockSize1 + i] = (algorithmFPType)1.0 / daal::internal::MathInst<algorithmFPType, cpu>::sSqrt(buf[i * blockSize1 + i]);
             }
         }
 
@@ -167,7 +167,7 @@ services::Status cosDistanceLowerPacked(const NumericTable * xTable, NumericTabl
             DAAL_INT lda = k, ldb = p, ldc = m;
 
             /* compute the distance between k1 and k2 blocks of rows in the input dataset */
-            Blas<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
+            BlasInst<algorithmFPType, cpu>::xxgemm(&transa, &transb, &m, &nn, &k, &alpha, x2, &lda, x1, &ldb, &beta, buf, &ldc);
 
             for (size_t i = 0; i < blockSize1; i++)
             {