Modify op usage

Author: Critsium-xy

source/module_hsolver/diago_dav_subspace.cpp

@@ -262,7 +262,12 @@ void Diago_DavSubspace<T, Device>::cal_grad(const HPsiFunc& hpsi_func,
         }
     }
 
-    gemm_op<T, Device>()(this->ctx,
+#ifdef __DSP
+    gemm_op_mt<T, Device>()
+#else
+    gemm_op<T, Device>()
+#endif
+                        (this->ctx,
                          'N',
                          'N',
                          this->dim,

source/module_hsolver/kernels/math_kernel_op.cpp

@@ -275,22 +275,36 @@ struct gemm_op<T, base_device::DEVICE_CPU>
                     const int& ldb,
                     const T* beta,
                     T* c,
-                    const int& ldc,
-                    bool use_dsp)
+                    const int& ldc,)
     {
-#ifdef __DSP
-        if (use_dsp){
-            BlasConnector::gemm(transb, transa, n, m, k, *alpha, b, ldb, a, lda, *beta, c, ldc, base_device::AbacusDevice_t::DspDevice);
-        }
-        else{
-            BlasConnector::gemm(transb, transa, n, m, k, *alpha, b, ldb, a, lda, *beta, c, ldc);
-        }     
-#else
         BlasConnector::gemm(transb, transa, n, m, k, *alpha, b, ldb, a, lda, *beta, c, ldc);
-#endif
     }
 };
 
+#ifdef __DSP
+template <typename T>
+struct gemm_op_mt<T, base_device::DEVICE_CPU>
+{
+    void operator()(const base_device::DEVICE_CPU* /*ctx*/,
+                    const char& transa,
+                    const char& transb,
+                    const int& m,
+                    const int& n,
+                    const int& k,
+                    const T* alpha,
+                    const T* a,
+                    const int& lda,
+                    const T* b,
+                    const int& ldb,
+                    const T* beta,
+                    T* c,
+                    const int& ldc)
+    {
+        BlasConnector::gemm(transb, transa, n, m, k, *alpha, b, ldb, a, lda, *beta, c, ldc, base_device::AbacusDevice_t::DspDevice);
+    }
+};
+#endif
+
 template <typename T>
 struct matrixTranspose_op<T, base_device::DEVICE_CPU>
 {

source/module_hsolver/kernels/math_kernel_op.h

@@ -261,9 +261,39 @@ template <typename T, typename Device> struct gemm_op {
   void operator()(const Device *d, const char &transa, const char &transb,
                   const int &m, const int &n, const int &k, const T *alpha,
                   const T *a, const int &lda, const T *b, const int &ldb,
-                  const T *beta, T *c, const int &ldc, bool usd_dsp = false);
+                  const T *beta, T *c, const int &ldc);
 };
 
+#ifdef __DSP
+// compute C = alpha * op(A) * op(B) + beta * C on DSP Hardware
+template <typename T, typename Device> struct gemm_op_mt {
+  /// @brief C = alpha * op(A) * op(B) + beta * C
+  ///
+  /// Input Parameters
+  /// \param d : the type of computing device
+  /// \param transa : whether to transpose matrix A
+  /// \param transb : whether to transpose matrix B
+  /// \param m : first dimension of matrix mulplication
+  /// \param n : second dimension of matrix mulplication
+  /// \param k : third dimension of matrix mulplication
+  /// \param alpha : input constant alpha
+  /// \param a : input matrix A
+  /// \param lda : leading dimention of A
+  /// \param b : input matrix B
+  /// \param ldb : leading dimention of A
+  /// \param beta : input constant beta
+  /// \param c : input matrix C
+  /// \param ldc : leading dimention of C
+  ///
+  /// Output Parameters
+  /// \param c : output matrix C
+  void operator()(const Device *d, const char &transa, const char &transb,
+                  const int &m, const int &n, const int &k, const T *alpha,
+                  const T *a, const int &lda, const T *b, const int &ldb,
+                  const T *beta, T *c, const int &ldc);
+};
+#endif
+
 template <typename T, typename Device> struct matrixTranspose_op {
   /// @brief transpose the input matrix
   ///