Remove ctx in scal_op

Author: Critsium-xy

source/module_base/kernels/cuda/math_kernel_op.cu

@@ -790,8 +790,7 @@ void gemv_op<std::complex<double>, base_device::DEVICE_GPU>::operator()(const ba
 }
 
 template <>
-void scal_op<float, base_device::DEVICE_GPU>::operator()(const base_device::DEVICE_GPU* d,
-                                                         const int& N,
+void scal_op<float, base_device::DEVICE_GPU>::operator()(const int& N,
                                                          const std::complex<float>* alpha,
                                                          std::complex<float>* X,
                                                          const int& incx)
@@ -800,8 +799,7 @@ void scal_op<float, base_device::DEVICE_GPU>::operator()(const base_device::DEVI
 }
 
 template <>
-void scal_op<double, base_device::DEVICE_GPU>::operator()(const base_device::DEVICE_GPU* d,
-                                                          const int& N,
+void scal_op<double, base_device::DEVICE_GPU>::operator()(const int& N,
                                                           const std::complex<double>* alpha,
                                                           std::complex<double>* X,
                                                           const int& incx)

source/module_base/kernels/math_kernel_op.cpp

@@ -220,8 +220,7 @@ struct constantvector_addORsub_constantVector_op<T, base_device::DEVICE_CPU>
 template <typename FPTYPE>
 struct scal_op<FPTYPE, base_device::DEVICE_CPU>
 {
-    void operator()(const base_device::DEVICE_CPU* /*ctx*/,
-                    const int& N,
+    void operator()(const int& N,
                     const std::complex<FPTYPE>* alpha,
                     std::complex<FPTYPE>* X,
                     const int& incx)

source/module_base/kernels/math_kernel_op.h

@@ -90,7 +90,6 @@ template <typename T, typename Device> struct dot_real_op {
   /// while enabling planewave parallization strategy.
   ///
   /// Input Parameters
-  /// \param d : the type of computing device
   /// \param dim : array size
   /// \param psi_L : input array A
   /// \param psi_R : input array B
@@ -108,7 +107,6 @@ template <typename T, typename Device> struct vector_div_constant_op {
   /// @brief result[i] = vector[i] / constant
   ///
   /// Input Parameters
-  /// \param d : the type of computing device
   /// \param dim : array size
   /// \param vector : input array
   /// \param constant : input constant
@@ -124,15 +122,14 @@ template <typename FPTYPE, typename Device> struct scal_op {
   /// @brief x = alpha * x
   ///
   /// Input Parameters
-  /// \param d : the type of computing device
   /// \param N : array size
   /// \param alpha : input constant
   /// \param X : input array
   /// \param incx : computing strip of array X
   ///
   /// Output Parameters
   /// \param X : output array
-  void operator()(const Device *d, const int &N,
+  void operator()(const int &N,
                   const std::complex<FPTYPE> *alpha, std::complex<FPTYPE> *X,
                   const int &incx);
 };

source/module_base/kernels/rocm/math_kernel_op.hip.cu

@@ -708,8 +708,7 @@ void gemv_op<std::complex<double>, base_device::DEVICE_GPU>::operator()(const ba
 }
 
 template <>
-void scal_op<float, base_device::DEVICE_GPU>::operator()(const base_device::DEVICE_GPU* d,
-                                                         const int& N,
+void scal_op<float, base_device::DEVICE_GPU>::operator()(const int& N,
                                                          const std::complex<float>* alpha,
                                                          std::complex<float>* X,
                                                          const int& incx)
@@ -718,8 +717,7 @@ void scal_op<float, base_device::DEVICE_GPU>::operator()(const base_device::DEVI
 }
 
 template <>
-void scal_op<double, base_device::DEVICE_GPU>::operator()(const base_device::DEVICE_GPU* d,
-                                                          const int& N,
+void scal_op<double, base_device::DEVICE_GPU>::operator()(const int& N,
                                                           const std::complex<double>* alpha,
                                                           std::complex<double>* X,
                                                           const int& incx)

source/module_base/kernels/test/math_kernel_test.cpp

@@ -323,7 +323,7 @@ TEST_F(TestModuleHsolverMathKernel, axpy_op_cpu)
 
 TEST_F(TestModuleHsolverMathKernel, scal_op_cpu)
 {
-    scal_op_cpu()(cpu_ctx, dim, &alpha_scal, X_scal.data(), 1);
+    scal_op_cpu()(dim, &alpha_scal, X_scal.data(), 1);
     for (int i = 0; i < input.size(); i++)
     {
         EXPECT_LT(fabs(X_scal[i].imag() - output_scal_op[i].imag()), 1e-8);
@@ -567,7 +567,7 @@ TEST_F(TestModuleHsolverMathKernel, scal_op_gpu)
 
     // run
     ModuleBase::createGpuBlasHandle();
-    scal_op_gpu()(gpu_ctx, dim, &alpha_scal, X_scal_dev, 1);
+    scal_op_gpu()(dim, &alpha_scal, X_scal_dev, 1);
     ModuleBase::destoryBLAShandle();
 
     // syn the output data in GPU to CPU

source/module_hsolver/kernels/test/perf_math_kernel.cpp

@@ -199,7 +199,7 @@ BENCHMARK_DEFINE_F(PerfModuleHsolverMathKernel, BM_axpy_op_cpu)(benchmark::State
 
 BENCHMARK_DEFINE_F(PerfModuleHsolverMathKernel, BM_scal_op_cpu)(benchmark::State& state) {
     for (auto _ : state) {
-        scal_op_cpu()(cpu_ctx, dim_vector, &zconstant_a, test_zvector_a, 1);
+        scal_op_cpu()(dim_vector, &zconstant_a, test_zvector_a, 1);
     }
 }
 
@@ -268,7 +268,7 @@ BENCHMARK_DEFINE_F(PerfModuleHsolverMathKernel, BM_axpy_op_gpu)(benchmark::State
 
 BENCHMARK_DEFINE_F(PerfModuleHsolverMathKernel, BM_scal_op_gpu)(benchmark::State& state) {
     for (auto _ : state) {
-        scal_op_gpu()(gpu_ctx, dim_vector, &zconstant_a, test_zvector_a_gpu, 1);
+        scal_op_gpu()(dim_vector, &zconstant_a, test_zvector_a_gpu, 1);
     }
 }