[ trivial/hgemm ] Move hgemm_K1 to hgemm directory

- For consistency, hgemm_K1 function should reside under hgemm directory

**Self evaluation:**
1. Build test:     [X]Passed [ ]Failed [ ]Skipped
2. Run test:     [X]Passed [ ]Failed [ ]Skipped

Signed-off-by: skykongkong8 <ss.kong@samsung.com>

diff --git a/nntrainer/tensor/blas_neon.cpp b/nntrainer/tensor/blas_neon.cpp
index 8b931c729547b41e0f39852aac2d87a8aa21835d..0e429a6d37879687cbb269f26782c2009e8ec309 100644 (file)
--- a/nntrainer/tensor/blas_neon.cpp
+++ b/nntrainer/tensor/blas_neon.cpp
@@ -1634,21 +1634,6 @@ void hgemm(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M, uint32_t N,
   free(C32);
 }
 
-void hgemm_K1(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M,
-              uint32_t N, uint32_t K, float alpha, float beta, bool TransA,
-              bool TransB) {
-  unsigned int lda = (TransA) ? M : K;
-  unsigned int ldb = (TransB) ? K : N;
-  if (!TransA && TransB) {
-    hgemm_K1_transB(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
-  } else if (TransA && !TransB) {
-    hgemm_K1_transA(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
-  } else if (!TransA && !TransB) {
-    hgemm_K1_noTrans(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
-  } else { // TransA && TransB
-    hgemm_K1_transAB(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
-  }
-}
 
 void ele_mul(const unsigned int N, const __fp16 *X, const __fp16 *Y, __fp16 *Z,
              float alpha, float beta) {

diff --git a/nntrainer/tensor/blas_neon.h b/nntrainer/tensor/blas_neon.h
index 45eff5721fdb8854ea6cab64c2fab7ffdcf82576..736057f0f92e59bdb034cdc2c2fc4d7520211493 100644 (file)
--- a/nntrainer/tensor/blas_neon.h
+++ b/nntrainer/tensor/blas_neon.h
@@ -330,21 +330,6 @@ unsigned int isamax(const unsigned int N, const __fp16 *X);
 void hgemm(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M, uint32_t N,
            uint32_t K, float alpha, float beta, bool TransA, bool TransB);
 
-/**
- * @brief     hgemm computation with neon : Y = alpha*op(A)*op(B) + beta*C,
- * where op(X) is one of X or X**T
- * @param[in] A __fp16 * for Matrix A
- * @param[in] B __fp16 * for Matrix B
- * @param[in] C __fp16 * for Matrix C
- * @param[in] M number of op(A)'s and C's row
- * @param[in] N number of op(B)'s and C's columns
- * @param[in] K number of op(A)'s and columns and op(B)'s rows
- * @param[in] alpha float number
- * @param[in] beta float number
- */
-void hgemm_K1(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M,
-              uint32_t N, uint32_t K, float alpha, float beta, bool TransA,
-              bool TransB);
 
 /**
  * @brief squared root transformation with neon : X = sqrt(X)

diff --git a/nntrainer/tensor/hgemm/hgemm.cpp b/nntrainer/tensor/hgemm/hgemm.cpp
index fc99d701cbe8b7e829969af2de71be45eb4e255d..c5a144ceee0537467be50885975b629e64545b3a 100644 (file)
--- a/nntrainer/tensor/hgemm/hgemm.cpp
+++ b/nntrainer/tensor/hgemm/hgemm.cpp
@@ -1444,3 +1444,19 @@ void hgemm_transAB(const __fp16 *A, const __fp16 *B, float *C, unsigned int M,
   free(A_T);
   free(B_T);
 }
+
+void hgemm_K1(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M,
+              uint32_t N, uint32_t K, float alpha, float beta, bool TransA,
+              bool TransB) {
+  unsigned int lda = (TransA) ? M : K;
+  unsigned int ldb = (TransB) ? K : N;
+  if (!TransA && TransB) {
+    hgemm_K1_transB(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
+  } else if (TransA && !TransB) {
+    hgemm_K1_transA(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
+  } else if (!TransA && !TransB) {
+    hgemm_K1_noTrans(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
+  } else { // TransA && TransB
+    hgemm_K1_transAB(M, N, K, A, lda, B, ldb, C, N, alpha, beta);
+  }
+}

diff --git a/nntrainer/tensor/hgemm/hgemm.h b/nntrainer/tensor/hgemm/hgemm.h
index c380eb8304dbf5c5bd1cc6bcd873d775055ab545..45595e035f6de045e673d4dc2a208b99a62a08f9 100644 (file)
--- a/nntrainer/tensor/hgemm/hgemm.h
+++ b/nntrainer/tensor/hgemm/hgemm.h
@@ -483,3 +483,18 @@ void hgemm_transB_8x16(unsigned int M, unsigned int N, unsigned int K,
  */
 void hgemm_transAB(const __fp16 *A, const __fp16 *B, float *C, unsigned int M,
                    unsigned int N, unsigned int K, float alpha, float beta);
+/**
+ * @brief     hgemm computation with neon : Y = alpha*op(A)*op(B) + beta*C,
+ * where op(X) is one of X or X**T
+ * @param[in] A __fp16 * for Matrix A
+ * @param[in] B __fp16 * for Matrix B
+ * @param[in] C __fp16 * for Matrix C
+ * @param[in] M number of op(A)'s and C's row
+ * @param[in] N number of op(B)'s and C's columns
+ * @param[in] K number of op(A)'s and columns and op(B)'s rows
+ * @param[in] alpha float number
+ * @param[in] beta float number
+ */
+void hgemm_K1(const __fp16 *A, const __fp16 *B, __fp16 *C, uint32_t M,
+              uint32_t N, uint32_t K, float alpha, float beta, bool TransA,
+              bool TransB);